Project-Pro/luxmed6.pagedev.pl
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
Roman Pyrih
2026-04-28 09:27:26 +02:00
commit 968c7e1248
4942 changed files with 1507729 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

674
wp-content/plugins/duplicator-pro-v4.5.16.2/LICENSE.TXT Normal file
View File

@@ -0,0 +1,674 @@
GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU General Public License is a free, copyleft license for
software and other kinds of works.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users. We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors. 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
them 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 prevent others from denying you
these rights or asking you to surrender the rights. Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received. 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.
Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.
For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software. For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.
Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so. This is fundamentally incompatible with the aim of
protecting users' freedom to change the software. The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable. Therefore, we
have designed this version of the GPL to prohibit the practice for those
products. If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.
Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary. To prevent this, the GPL assures that
patents cannot be used to render the program non-free.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey 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;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If 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 convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Use with the GNU Affero General Public License.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU 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 that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation. If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
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.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
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.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
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
state 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) <year> <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 3 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, see <http://www.gnu.org/licenses/>.
Also add information on how to contact you by electronic and paper mail.
If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:
<program> Copyright (C) <year> <name of author>
This program 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, your program's commands
might be different; for a GUI interface, you would use an "about box".
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
<http://www.gnu.org/licenses/>.
The GNU 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 Lesser General
Public License instead of this License. But first, please read
<http://www.gnu.org/philosophy/why-not-lgpl.html>.

9
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/.htaccess Normal file
View File

@@ -0,0 +1,9 @@
<Files *.php>
Order Deny,Allow
Deny from all
</Files>
<Files index.php>
Order Allow,Deny
Allow from all
</Files>

166
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/amazons3addon/AmazonS3Addon.php Normal file
View File

@@ -0,0 +1,166 @@
<?php
/**
* FTP/SFTP ADDON
*
* Name: Duplicator PRO base
* Version: 1
* Author: Duplicator
* Author URI: https://duplicator.com/
*
* PHP version 5.3
*
* @category Duplicator
* @package Plugin
* @author Duplicator
* @copyright 2011-2021 Snapcreek LLC
* @license https://www.gnu.org/licenses/gpl-3.0.html GPLv3
* @version GIT: $Id$
* @link https://duplicator.com/
*/
namespace Duplicator\Addons\AmazonS3Addon;
use Duplicator\Addons\AmazonS3Addon\Models\AmazonS3Storage;
use Duplicator\Addons\AmazonS3Addon\Models\AmazonS3CompatibleStorage;
use Duplicator\Addons\AmazonS3Addon\Models\BackblazeStorage;
use Duplicator\Addons\AmazonS3Addon\Models\CloudflareStorage;
use Duplicator\Addons\AmazonS3Addon\Models\DigitalOceanStorage;
use Duplicator\Addons\AmazonS3Addon\Models\DreamStorage;
use Duplicator\Addons\AmazonS3Addon\Models\GoogleCloudStorage;
use Duplicator\Addons\AmazonS3Addon\Models\VultrStorage;
use Duplicator\Addons\AmazonS3Addon\Models\WasabiStorage;
use Duplicator\Addons\AmazonS3Addon\Utils\Autoloader;
use Duplicator\Core\Addons\AbstractAddonCore;
use Duplicator\Models\Storages\AbstractStorageEntity;
/**
* Storage ftp/sftp addon class
*/
class AmazonS3Addon extends AbstractAddonCore
{
const ADDON_PATH = __DIR__;
/**
* @return void
*/
public function init()
{
Autoloader::register();
add_action('duplicator_pro_daily_actions', [__CLASS__, 'purgeOldS3MultipartUploads']);
add_action('duplicator_pro_register_storage_types', [$this, 'registerStorages']);
add_filter('duplicator_template_file', [__CLASS__, 'getTemplateFile'], 10, 2);
add_filter('duplicator_usage_stats_storages_infos', [__CLASS__, 'getStorageUsageStats'], 10, 1);
}
/**
* Register storages
*
* @return void
*/
public function registerStorages()
{
AmazonS3Storage::registerType();
AmazonS3CompatibleStorage::registerType();
GoogleCloudStorage::registerType();
BackblazeStorage::registerType();
DreamStorage::registerType();
DigitalOceanStorage::registerType();
VultrStorage::registerType();
CloudflareStorage::registerType();
WasabiStorage::registerType();
}
/**
* Return template file path
*
* @param string $path path to the template file
* @param string $slugTpl slug of the template
*
* @return string
*/
public static function getTemplateFile($path, $slugTpl)
{
if (strpos($slugTpl, 'amazons3addon/') === 0) {
return self::getAddonPath() . '/template/' . $slugTpl . '.php';
}
return $path;
}
/**
* Get storage usage stats
*
* @param array<string,int> $storageNums Storages num
*
* @return array<string,int>
*/
public static function getStorageUsageStats($storageNums)
{
if (($storages = AbstractStorageEntity::getAll()) === false) {
$storages = [];
}
$storageNums['storages_s3_count'] = 0;
$storageNums['storages_s3_compatible_count'] = 0;
foreach ($storages as $index => $storage) {
switch ($storage->getStype()) {
case AmazonS3Storage::getSType():
$storageNums['storages_s3_count']++;
break;
case AmazonS3CompatibleStorage::getSType():
case GoogleCloudStorage::getSType():
case BackblazeStorage::getSType():
case DreamStorage::getSType():
case DigitalOceanStorage::getSType():
case VultrStorage::getSType():
case CloudflareStorage::getSType():
case WasabiStorage::getSType():
$storageNums['storages_s3_compatible_count']++;
break;
}
}
return $storageNums;
}
/**
* Purge old S3 multipart uploads
*
* @return void
*/
public static function purgeOldS3MultipartUploads()
{
if (($storages = AbstractStorageEntity::getAll()) == false) {
return;
}
foreach ($storages as $storage) {
if (!$storage instanceof \Duplicator\Addons\AmazonS3Addon\Models\AmazonS3Storage) {
continue;
}
$storage->purgeMultipartUpload();
}
}
/**
*
* @return string
*/
public static function getAddonPath()
{
return __DIR__;
}
/**
*
* @return string
*/
public static function getAddonFile()
{
return __FILE__;
}
}

245
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/amazons3addon/src/Models/AmazonS3CompatibleStorage.php Normal file
View File

@@ -0,0 +1,245 @@
<?php
/**
*
* @package Duplicator
* @copyright (c) 2022, Snap Creek LLC
*/
namespace Duplicator\Addons\AmazonS3Addon\Models;
use Duplicator\Core\Views\TplMng;
use Duplicator\Libs\Snap\SnapUtil;
class AmazonS3CompatibleStorage extends AmazonS3Storage
{
/**
* Get default config
*
* @return array<string,scalar>
*/
protected static function getDefaultConfig()
{
$config = parent::getDefaultConfig();
$config = array_merge($config, ['ACL_full_control' => false]);
return $config;
}
/**
* Return the storage type
*
* @return int
*/
public static function getSType()
{
return 8;
}
/**
* Returns the storage type name.
*
* @return string
*/
public static function getStypeName()
{
return __('Amazon S3 Compatible', 'duplicator-pro');
}
/**
* Returns an html anchor tag of location or a string
*
* @return string Returns an html anchor tag with the storage location as a hyperlink or just a plain string
*/
public function getHtmlLocationLink()
{
if (preg_match('/^http(s)?:\\/\\//i', $this->getLocationString())) {
return '<a href="' . esc_url($this->getLocationString()) . '" target="_blank" >' . esc_html($this->getLocationLabel()) . '</a>';
} else {
return '<span>' . esc_html($this->getLocationString()) . '</span>';
}
}
/**
* Get storage location string
*
* @return string
*/
public function getLocationString()
{
return '/' . $this->config['bucket'] . $this->getStorageFolder();
}
/**
* Returns the storage location label.
*
* @return string The storage location label
*/
protected function getLocationLabel()
{
return '/' . $this->config['bucket'] . $this->getStorageFolder();
}
/**
* Returns a list of S3 compatible providers
*
* @return string[]
*/
public static function getCompatibleProviders()
{
return array(
'Aruba',
'Cloudian',
'Cloudn',
'Connectria',
'Constant',
'Exoscal',
'Eucalyptus',
'Nifty',
'Nimbula',
'Minio',
);
}
/**
* Get priority, used to sort storages.
* 100 is neutral value, 0 is the highest priority
*
* @return int
*/
public static function getPriority()
{
return 160;
}
/**
* Render form config fields
*
* @param bool $echo Echo or return
*
* @return string
*/
public function renderConfigFields($echo = true)
{
return TplMng::getInstance()->render(
'amazons3addon/configs/all_s3_compatible',
[
'storage' => $this,
'maxPackages' => $this->config['max_packages'],
'storageFolder' => $this->config['storage_folder'],
'accessKey' => $this->config['access_key'],
'bucket' => $this->config['bucket'],
'region' => $this->config['region'],
'endpoint' => $this->config['endpoint'],
'secretKey' => $this->config['secret_key'],
'storageClass' => $this->config['storage_class'],
'aclFullControl' => $this->config['ACL_full_control'],
'isAutofillEndpoint' => $this->isAutofillEndpoint(),
'isAutofillRegion' => $this->isAutofillRegion(),
'isAclSupported' => $this->isACLSupported(),
'aclDescription' => $this->getACLDescription(),
'documentationLinks' => $this->getDocumentationLinks(),
],
$echo
);
}
/**
* Get documentation links
*
* @return array<int,array<string,string>>
*/
protected static function getDocumentationLinks()
{
return [
[
'label' => __('S3 Compatibility API', 'duplicator-pro'),
'url' => 'https://docs.aws.amazon.com/AmazonS3/latest/API/Welcome.html',
],
];
}
/**
* Return true if the endpoint is generated automatically
*
* @return bool
*/
protected function isAutofillEndpoint()
{
return false;
}
/**
* Return true if the region is generated automatically
*
* @return bool
*/
protected function isAutofillRegion()
{
return false;
}
/**
* Return true if the ACL is supported
*
* @return bool
*/
protected function isACLSupported()
{
return true;
}
/**
* Get ACL description
*
* @return string
*/
protected function getACLDescription()
{
return __(
"This option only works if the storage provider supports the 'bucket-owner-full-control' object-level canned ACL.",
'duplicator-pro'
);
}
/**
* Update data from http request, this method don't save data, just update object properties
*
* @param string $message Message
*
* @return bool True if success and all data is valid, false otherwise
*/
public function updateFromHttpRequest(&$message = '')
{
if ((parent::updateFromHttpRequest($message) === false)) {
return false;
}
$this->config['endpoint'] = SnapUtil::sanitizeTextInput(SnapUtil::INPUT_REQUEST, 's3_endpoint');
$this->config['ACL_full_control'] = $this->isACLSupported() ?
SnapUtil::sanitizeBoolInput(SnapUtil::INPUT_REQUEST, 's3_ACL_full_control') : false;
return true;
}
/**
* Register storage type
*
* @return void
*/
public static function registerType()
{
parent::registerType();
if (self::class === static::class) {
// only add filter for current storage and not inherited
add_filter('duplicator_pro_storage_type_class', function ($class, $type, $data) {
if ($type == AmazonS3Storage::getSType()) {
$isLegacy = (!isset($data['legacyEntity']) || $data['legacyEntity'] === true);
$provider = (isset($data['s3_provider']) ? $data['s3_provider'] : '');
if ($isLegacy && $provider == 'other') {
$class = __CLASS__;
}
}
return $class;
}, 10, 3);
}
}
}

538
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/amazons3addon/src/Models/AmazonS3Storage.php Normal file
View File

@@ -0,0 +1,538 @@
<?php
/**
*
* @package Duplicator
* @copyright (c) 2022, Snap Creek LLC
*/
namespace Duplicator\Addons\AmazonS3Addon\Models;
use DUP_PRO_Global_Entity;
use Duplicator\Core\Views\TplMng;
use Duplicator\Libs\Snap\SnapUtil;
use Duplicator\Models\DynamicGlobalEntity;
use Duplicator\Models\Storages\AbstractStorageEntity;
use Exception;
class AmazonS3Storage extends AbstractStorageEntity
{
/** @var int */
const DEFAULT_UPLOAD_CHUNK_SIZE_IN_KB = 6000;
/** @var int */
const UPLOAD_CHUNK_MIN_SIZE_IN_KB = 5 * 1024;
/**
* Get default config
*
* @return array<string,scalar>
*/
protected static function getDefaultConfig()
{
$config = parent::getDefaultConfig();
$config = array_merge(
$config,
[
'access_key' => '',
'bucket' => '',
'region' => '',
'endpoint' => '',
'secret_key' => '',
'storage_class' => 'STANDARD',
'ACL_full_control' => true,
]
);
return $config;
}
/**
* Return the field label
*
* @param string $field Field name
*
* @return string
*/
public static function getFieldLabel($field)
{
switch ($field) {
case 'accessKey':
return __('Access Key', 'duplicator-pro');
case 'secretKey':
return __('Secret Key', 'duplicator-pro');
case 'region':
return __('Region', 'duplicator-pro');
case 'endpoint':
return __('Endpoint', 'duplicator-pro');
case 'bucket':
return __('Bucket', 'duplicator-pro');
case 'aclFullControl':
return __('Additional Settings', 'duplicator-pro');
default:
throw new Exception("Unknown field: $field");
}
}
/**
* Serialize
*
* Wakeup method.
*
* @return void
*/
public function __wakeup()
{
parent::__wakeup();
if ($this->legacyEntity) {
// Old storage entity
$this->legacyEntity = false;
// Make sure the storage type is right from the old entity
$this->storage_type = $this->getSType();
$this->config = [
'storage_folder' => $this->s3_storage_folder,
'max_packages' => $this->s3_max_files,
'access_key' => $this->s3_access_key,
'bucket' => $this->s3_bucket,
'region' => $this->s3_region,
'endpoint' => $this->s3_endpoint,
'secret_key' => $this->s3_secret_key,
'storage_class' => $this->s3_storage_class,
'ACL_full_control' => $this->s3_ACL_full_control,
];
// reset old values
$this->s3_storage_folder = '';
$this->s3_max_files = 10;
$this->s3_access_key = '';
$this->s3_bucket = '';
$this->s3_provider = 'amazon';
$this->s3_region = '';
$this->s3_endpoint = '';
$this->s3_secret_key = '';
$this->s3_storage_class = 'STANDARD';
$this->s3_ACL_full_control = true;
}
}
/**
* Return the storage type
*
* @return int
*/
public static function getSType()
{
return 4;
}
/**
* Returns the storage type icon.
*
* @return string Returns the icon
*/
public static function getStypeIcon()
{
return '<img src="' . esc_url(static::getIconUrl()) . '" class="dup-storage-icon" alt="' . esc_attr(static::getStypeName()) . '" />';
}
/**
* Returns the storage type icon url.
*
* @return string The icon url
*/
protected static function getIconUrl()
{
return DUPLICATOR_PRO_IMG_URL . '/aws.svg';
}
/**
* Returns the storage type name.
*
* @return string
*/
public static function getStypeName()
{
return __('Amazon S3', 'duplicator-pro');
}
/**
* Get priority, used to sort storages.
* 100 is neutral value, 0 is the highest priority
*
* @return int
*/
public static function getPriority()
{
return 150;
}
/**
* Get storage location string
*
* @return string
*/
public function getLocationString()
{
$params = [
'region' => $this->config['region'],
'bucket' => $this->config['bucket'],
'prefix' => $this->getStorageFolder(),
];
return 'https://console.aws.amazon.com/s3/home' . '?' . http_build_query($params);
}
/**
* Returns an html anchor tag of location
*
* @return string Returns an html anchor tag with the storage location as a hyperlink.
*
* @example
* OneDrive Example return
* <a target="_blank" href="https://1drv.ms/f/sAFrQtasdrewasyghg">https://1drv.ms/f/sAFrQtasdrewasyghg</a>
*/
public function getHtmlLocationLink()
{
return '<a href="' . esc_url($this->getLocationString()) . '" target="_blank" >' . esc_html($this->getLocationLabel()) . '</a>';
}
/**
* Returns the storage location label.
*
* @return string The storage location label
*/
protected function getLocationLabel()
{
return 's3://' . $this->config['bucket'] . $this->getStorageFolder();
}
/**
* Check if storage is supported
*
* @return bool
*/
public static function isSupported()
{
return SnapUtil::isCurlEnabled(true, true);
}
/**
* Get supported notice, displayed if storage isn't supported
*
* @return string html string or empty if storage is supported
*/
public static function getNotSupportedNotice()
{
if (static::isSupported()) {
return '';
}
if (!SnapUtil::isCurlEnabled()) {
$result = sprintf(
__(
"The Storage %s requires the PHP cURL extension and related functions to be enabled.",
'duplicator-pro'
),
static::getStypeName()
);
} elseif (!SnapUtil::isCurlEnabled(true, true)) {
$result = sprintf(
__(
"The Storage %s requires 'curl_multi_' type functions to be enabled. One or more are disabled on your server.",
'duplicator-pro'
),
static::getStypeName()
);
} else {
$result = sprintf(
__(
'The Storage %s is not supported on this server.',
'duplicator-pro'
),
static::getStypeName()
);
}
return esc_html($result);
}
/**
* Check if storage is valid
*
* @return bool Return true if storage is valid and ready to use, false otherwise
*/
public function isValid()
{
return $this->getAdapter()->isValid();
}
/**
* Get action key text
*
* @param string $key Key name (action, pending, failed, cancelled, success)
*
* @return string
*/
protected function getActionKeyText($key)
{
switch ($key) {
case 'action':
return sprintf(
__('Transferring to %1$s folder:<br/> <i>%2$s</i>', "duplicator-pro"),
$this->getStypeName(),
$this->getStorageFolder()
);
case 'pending':
return sprintf(
__('Transfer to %1$s folder %2$s is pending', "duplicator-pro"),
$this->getStypeName(),
$this->getStorageFolder()
);
case 'failed':
return sprintf(
__('Failed to transfer to %1$s folder %2$s', "duplicator-pro"),
$this->getStypeName(),
$this->getStorageFolder()
);
case 'cancelled':
return sprintf(
__('Cancelled before could transfer to %1$s folder %2$s', "duplicator-pro"),
$this->getStypeName(),
$this->getStorageFolder()
);
case 'success':
return sprintf(
__('Transferred package to %1$s folder %2$s', "duplicator-pro"),
$this->getStypeName(),
$this->getStorageFolder()
);
default:
throw new Exception('Invalid key');
}
}
/**
* Render form config fields
*
* @param bool $echo Echo or return
*
* @return string
*/
public function renderConfigFields($echo = true)
{
return TplMng::getInstance()->render(
'amazons3addon/configs/amazon_s3',
[
'storage' => $this,
'maxPackages' => $this->config['max_packages'],
'storageFolder' => $this->config['storage_folder'],
'accessKey' => $this->config['access_key'],
'bucket' => $this->config['bucket'],
'region' => $this->config['region'],
'endpoint' => $this->config['endpoint'],
'secretKey' => $this->config['secret_key'],
'storageClass' => $this->config['storage_class'],
'aclFullControl' => $this->config['ACL_full_control'],
'regionOptions' => self::regionOptions(),
],
$echo
);
}
/**
* Update data from http request, this method don't save data, just update object properties
*
* @param string $message Message
*
* @return bool True if success and all data is valid, false otherwise
*/
public function updateFromHttpRequest(&$message = '')
{
if ((parent::updateFromHttpRequest($message) === false)) {
return false;
}
$this->config['max_packages'] = SnapUtil::sanitizeIntInput(SnapUtil::INPUT_REQUEST, 's3_max_files', 10);
$this->config['storage_folder'] = self::getSanitizedInputFolder('_s3_storage_folder');
$this->config['access_key'] = SnapUtil::sanitizeTextInput(SnapUtil::INPUT_REQUEST, 's3_access_key');
$secretKey = SnapUtil::sanitizeTextInput(SnapUtil::INPUT_REQUEST, 's3_secret_key');
if (strlen($secretKey) > 0) {
$this->config['secret_key'] = $secretKey;
}
$this->config['region'] = SnapUtil::sanitizeTextInput(SnapUtil::INPUT_REQUEST, 's3_region');
$this->config['storage_class'] = SnapUtil::sanitizeTextInput(SnapUtil::INPUT_REQUEST, 's3_storage_class');
$this->config['bucket'] = SnapUtil::sanitizeTextInput(SnapUtil::INPUT_REQUEST, 's3_bucket');
$message = sprintf(
__('Storage Updated.', 'duplicator-pro'),
$this->config['server'],
$this->getStorageFolder()
);
return true;
}
/**
* Get full s3 client
*
* @return S3StorageAdapter
*/
protected function getAdapter()
{
$global = DUP_PRO_Global_Entity::getInstance();
return new S3StorageAdapter(
$this->config['access_key'],
$this->config['secret_key'],
$this->config['region'],
$this->config['bucket'],
$this->config['storage_folder'],
$this->config['endpoint'],
$this->config['storage_class'],
$global->ipv4_only,
!$global->ssl_disableverify,
($global->ssl_useservercerts ? '' : DUPLICATOR_PRO_CERT_PATH),
$this->config['ACL_full_control']
);
}
/**
* Returns value => label pairs for region drop-down options for S3 Amazon Direct storage type
*
* @return string[]
*/
protected static function regionOptions()
{
return array(
"us-east-1" => __("US East (N. Virginia)", 'duplicator-pro'),
"us-east-2" => __("US East (Ohio)", 'duplicator-pro'),
"us-west-1" => __("US West (N. California)", 'duplicator-pro'),
"us-west-2" => __("US West (Oregon)", 'duplicator-pro'),
"af-south-1" => __("Africa (Cape Town)", 'duplicator-pro'),
"ap-east-1" => __("Asia Pacific (Hong Kong)", 'duplicator-pro'),
"ap-south-1" => __("Asia Pacific (Mumbai)", 'duplicator-pro'),
"ap-northeast-1" => __("Asia Pacific (Tokyo)", 'duplicator-pro'),
"ap-northeast-2" => __("Asia Pacific (Seoul)", 'duplicator-pro'),
"ap-northeast-3" => __("Asia Pacific (Osaka-Local)", 'duplicator-pro'),
"ap-southeast-1" => __("Asia Pacific (Singapore)", 'duplicator-pro'),
"ap-southeast-2" => __("Asia Pacific (Sydney)", 'duplicator-pro'),
"ap-southeast-3" => __("Asia Pacific (Jakarta)", 'duplicator-pro'),
"ca-central-1" => __("Canada (Central)", 'duplicator-pro'),
"cn-north-1" => __("China (Beijing)", 'duplicator-pro'),
"cn-northwest-1" => __("China (Ningxia)", 'duplicator-pro'),
"eu-central-1" => __("EU (Frankfurt)", 'duplicator-pro'),
"eu-west-1" => __("EU (Ireland)", 'duplicator-pro'),
"eu-west-2" => __("EU (London)", 'duplicator-pro'),
"eu-west-3" => __("EU (Paris)", 'duplicator-pro'),
"eu-south-1" => __("Europe (Milan)", 'duplicator-pro'),
"eu-north-1" => __("Europe (Stockholm)", 'duplicator-pro'),
"me-south-1" => __("Middle East (Bahrain)", 'duplicator-pro'),
"sa-east-1" => __("South America (Sao Paulo)", 'duplicator-pro'),
);
}
/**
* Register storage type
*
* @return void
*/
public static function registerType()
{
parent::registerType();
add_action('duplicator_update_global_storage_settings', function () {
$dGlobal = DynamicGlobalEntity::getInstance();
foreach (static::getDefaultSettings() as $key => $default) {
$value = SnapUtil::sanitizeIntInput(SnapUtil::INPUT_REQUEST, $key, $default);
$dGlobal->setVal($key, $value);
}
$dGlobal->save();
});
}
/**
* Get upload chunk size in bytes
*
* @return int bytes
*/
public function getUploadChunkSize()
{
$dGlobal = DynamicGlobalEntity::getInstance();
return $dGlobal->getVal('s3_upload_part_size_in_kb', self::DEFAULT_UPLOAD_CHUNK_SIZE_IN_KB) * 1024;
}
/**
* Get upload chunk timeout in seconds
*
* @return int timeout in microseconds, 0 unlimited
*/
public function getUploadChunkTimeout()
{
$global = DUP_PRO_Global_Entity::getInstance();
return (int) ($global->php_max_worker_time_in_sec <= 0 ? 0 : $global->php_max_worker_time_in_sec * SECONDS_IN_MICROSECONDS);
}
/**
* Get default settings
*
* @return array<string, scalar>
*/
protected static function getDefaultSettings()
{
return ['s3_upload_part_size_in_kb' => 6000];
}
/**
* @return void
*/
public static function renderGlobalOptions()
{
if (self::class !== static::class) {
return;
}
$values = static::getDefaultSettings();
$dGlobal = DynamicGlobalEntity::getInstance();
foreach ($values as $key => $default) {
$values[$key] = $dGlobal->getVal($key, $default);
}
?>
<h3 class="title"><?php esc_html_e("Amazon S3", 'duplicator-pro') ?></h3>
<hr size="1" />
<table class="form-table">
<tr valign="top">
<th scope="row"><label><?php esc_html_e("Upload Chunk Size", 'duplicator-pro'); ?></label></th>
<td>
<input
class="dup-narrow-input text-right"
name="s3_upload_part_size_in_kb"
id="s3_upload_part_size_in_kb"
type="number"
min="<?php echo self::UPLOAD_CHUNK_MIN_SIZE_IN_KB; ?>"
max="5243000"
data-parsley-required
data-parsley-type="number"
data-parsley-errors-container="#s3_upload_chunksize_in_kb_error_container"
value="<?php echo $values['s3_upload_part_size_in_kb']; ?>"
>&nbsp;<b>KB</b>
<div id="s3_upload_chunksize_in_kb_error_container" class="duplicator-error-container"></div>
<p class="description">
<?php esc_html_e('How much should be uploaded to Amazon S3 per attempt. Higher=faster but less reliable.', 'duplicator-pro'); ?>
<?php echo esc_html(sprintf(__('Min size %skb.', 'duplicator-pro'), self::UPLOAD_CHUNK_MIN_SIZE_IN_KB)); ?>
</p>
</td>
</tr>
</table>
<?php
}
/**
* Purge old multipart uploads
*
* @return void
*/
public function purgeMultipartUpload()
{
$this->getAdapter()->abortMultipartUploads(2);
}
}

163
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/amazons3addon/src/Models/BackblazeStorage.php Normal file
View File

@@ -0,0 +1,163 @@
<?php
/**
*
* @package Duplicator
* @copyright (c) 2022, Snap Creek LLC
*/
namespace Duplicator\Addons\AmazonS3Addon\Models;
class BackblazeStorage extends AmazonS3CompatibleStorage
{
/**
* Get default config
*
* @return array<string,scalar>
*/
protected static function getDefaultConfig()
{
$config = parent::getDefaultConfig();
$config['ACL_full_control'] = false;
return $config;
}
/**
* Return the storage type
*
* @return int
*/
public static function getSType()
{
return 9;
}
/**
* Get storage location string
*
* @return string
*/
public function getLocationString()
{
return 'https://secure.backblaze.com/b2_buckets.htm';
}
/**
* Returns the storage location label.
*
* @return string The storage location label
*/
protected function getLocationLabel()
{
return __('Bucket List', 'duplicator-pro');
}
/**
* Returns the storage type name.
*
* @return string
*/
public static function getStypeName()
{
return __('Backblaze B2', 'duplicator-pro');
}
/**
* Get priority, used to sort storages.
* 100 is neutral value, 0 is the highest priority
*
* @return int
*/
public static function getPriority()
{
return 200;
}
/**
* Returns the storage type icon url.
*
* @return string The icon url
*/
protected static function getIconUrl()
{
return DUPLICATOR_PRO_IMG_URL . '/backblaze.svg';
}
/**
* Get documentation links
*
* @return array<int,array<string,string>>
*/
protected static function getDocumentationLinks()
{
return [
[
'label' => __('Overview', 'duplicator-pro'),
'url' => 'https://www.backblaze.com/b2/docs/',
],
[
'label' => __('S3 Compatible API', 'duplicator-pro'),
'url' => 'https://www.backblze.com/b2/docs/s3_compatible_api.html',
],
];
}
/**
* Return the field label
*
* @param string $field Field name
*
* @return string
*/
public static function getFieldLabel($field)
{
switch ($field) {
case 'accessKey':
return __('Key ID', 'duplicator-pro');
case 'secretKey':
return __('Application Key', 'duplicator-pro');
}
return parent::getFieldLabel($field);
}
/**
* Return true if ACL is supported
*
* @return bool
*/
protected function isACLSupported()
{
return false;
}
/**
* Return true if the region is generated automatically
*
* @return bool
*/
public function isAutofillRegion()
{
return true;
}
/**
* Register storage type
*
* @return void
*/
public static function registerType()
{
parent::registerType();
add_filter('duplicator_pro_storage_type_class', function ($class, $type, $data) {
if ($type == AmazonS3Storage::getSType()) {
$isLegacy = (!isset($data['legacyEntity']) || $data['legacyEntity'] === true);
$provider = (isset($data['s3_provider']) ? $data['s3_provider'] : '');
if ($isLegacy && $provider == 'backblaze') {
$class = __CLASS__;
}
}
return $class;
}, 10, 3);
}
}

91
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/amazons3addon/src/Models/CloudflareStorage.php Normal file
View File

@@ -0,0 +1,91 @@
<?php
/**
*
* @package Duplicator
* @copyright (c) 2022, Snap Creek LLC
*/
namespace Duplicator\Addons\AmazonS3Addon\Models;
class CloudflareStorage extends AmazonS3CompatibleStorage
{
/**
* Return the storage type
*
* @return int
*/
public static function getSType()
{
return 11;
}
/**
* Returns the storage type name.
*
* @return string
*/
public static function getStypeName()
{
return __('Cloudflare R2', 'duplicator-pro');
}
/**
* Get storage location string
*
* @return string
*/
public function getLocationString()
{
return 'https://dash.cloudflare.com/';
}
/**
* Returns the storage location label.
*
* @return string The storage location label
*/
protected function getLocationLabel()
{
return __('Dashboard', 'duplicator-pro');
}
/**
* Returns the storage type icon url.
*
* @return string The icon url
*/
protected static function getIconUrl()
{
return DUPLICATOR_PRO_IMG_URL . '/cloudflare.svg';
}
/**
* Return true if the ACL is supported
*
* @return bool
*/
protected function isACLSupported()
{
return false;
}
/**
* Get documentation links
*
* @return array<int,array<string,string>>
*/
protected static function getDocumentationLinks()
{
return [
[
'label' => __('Overview', 'duplicator-pro'),
'url' => 'https://developers.cloudflare.com/r2/',
],
[
'label' => __('S3 Compatible API', 'duplicator-pro'),
'url' => 'https://developers.cloudflare.com/r2/api/s3/api/',
],
];
}
}

91
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/amazons3addon/src/Models/DigitalOceanStorage.php Normal file
View File

@@ -0,0 +1,91 @@
<?php
/**
*
* @package Duplicator
* @copyright (c) 2022, Snap Creek LLC
*/
namespace Duplicator\Addons\AmazonS3Addon\Models;
class DigitalOceanStorage extends AmazonS3CompatibleStorage
{
/**
* Return the storage type
*
* @return int
*/
public static function getSType()
{
return 14;
}
/**
* Returns the storage type name.
*
* @return string
*/
public static function getStypeName()
{
return __('Digital Ocean Spaces', 'duplicator-pro');
}
/**
* Return true if the region is generated automatically
*
* @return bool
*/
public function isAutofillRegion()
{
return true;
}
/**
* Return true if the ACL is supported
*
* @return bool
*/
protected function isACLSupported()
{
return false;
}
/**
* Returns the storage type icon url.
*
* @return string The icon url
*/
protected static function getIconUrl()
{
return DUPLICATOR_PRO_IMG_URL . '/digital-ocean.svg';
}
/**
* Get storage location string
*
* @return string
*/
public function getLocationString()
{
return 'https://cloud.digitalocean.com/spaces/' . $this->config['bucket'] . $this->config['storage_folder'];
}
/**
* Get documentation links
*
* @return array<int,array<string,string>>
*/
protected static function getDocumentationLinks()
{
return [
[
'label' => __('Spaces Object Storage', 'duplicator-pro'),
'url' => 'https://docs.digitalocean.com/products/spaces/',
],
[
'label' => __('Spaces API', 'duplicator-pro'),
'url' => 'https://docs.digitalocean.com/reference/api/spaces-api/',
],
];
}
}

101
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/amazons3addon/src/Models/DreamStorage.php Normal file
View File

@@ -0,0 +1,101 @@
<?php
/**
*
* @package Duplicator
* @copyright (c) 2022, Snap Creek LLC
*/
namespace Duplicator\Addons\AmazonS3Addon\Models;
class DreamStorage extends AmazonS3CompatibleStorage
{
/**
* Return the storage type
*
* @return int
*/
public static function getSType()
{
return 13;
}
/**
* Returns the storage type name.
*
* @return string
*/
public static function getStypeName()
{
return __('Dream Objects', 'duplicator-pro');
}
/**
* Returns the storage type icon url.
*
* @return string The icon url
*/
protected static function getIconUrl()
{
return DUPLICATOR_PRO_IMG_URL . '/dreamhost.svg';
}
/**
* Return true if the region is generated automatically
*
* @return bool
*/
public function isAutofillRegion()
{
return true;
}
/**
* Return true if the ACL is supported
*
* @return bool
*/
protected function isACLSupported()
{
return false;
}
/**
* Get storage location string
*
* @return string
*/
public function getLocationString()
{
return 'https://panel.dreamhost.com/index.cgi?tree=cloud.objects';
}
/**
* Returns the storage location label.
*
* @return string The storage location label
*/
protected function getLocationLabel()
{
return __('Bucket List', 'duplicator-pro');
}
/**
* Get documentation links
*
* @return array<int,array<string,string>>
*/
protected static function getDocumentationLinks()
{
return [
[
'label' => __('Overview', 'duplicator-pro'),
'url' => 'https://help.dreamhost.com/hc/en-us/articles/214823108-DreamObjects-overview',
],
[
'label' => __('S3 Compatible API', 'duplicator-pro'),
'url' => 'https://help.dreamhost.com/hc/en-us/articles/217590537-How-To-Use-DreamObjects-S3-compatible-API',
],
];
}
}

80
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/amazons3addon/src/Models/GoogleCloudStorage.php Normal file
View File

@@ -0,0 +1,80 @@
<?php
/**
*
* @package Duplicator
* @copyright (c) 2022, Snap Creek LLC
*/
namespace Duplicator\Addons\AmazonS3Addon\Models;
class GoogleCloudStorage extends AmazonS3CompatibleStorage
{
/**
* Return the storage type
*
* @return int
*/
public static function getSType()
{
return 16;
}
/**
* Returns the storage type name.
*
* @return string
*/
public static function getStypeName()
{
return __('Google Cloud Storage', 'duplicator-pro');
}
/**
* Get storage location string
*
* @return string
*/
public function getLocationString()
{
return 'https://console.cloud.google.com/storage/browser/' . $this->config['bucket'] . $this->config['storage_folder'];
}
/**
* Returns the storage type icon url.
*
* @return string The icon url
*/
protected static function getIconUrl()
{
return DUPLICATOR_PRO_IMG_URL . '/google-cloud.svg';
}
/**
* Get ACL description
*
* @return string
*/
protected function getACLDescription()
{
return __(
"Make sure to change the 'Access Control' to 'Fine Grained' for this setting to work.",
'duplicator-pro'
);
}
/**
* Get documentation links
*
* @return array<int,array<string,string>>
*/
protected static function getDocumentationLinks()
{
return [
[
'label' => __('Interoperability with S3 API', 'duplicator-pro'),
'url' => 'https://cloud.google.com/storage/docs/interoperability',
],
];
}
}

1048
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/amazons3addon/src/Models/S3StorageAdapter.php Normal file
View File

File diff suppressed because it is too large Load Diff

87
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/amazons3addon/src/Models/VultrStorage.php Normal file
View File

@@ -0,0 +1,87 @@
<?php
/**
*
* @package Duplicator
* @copyright (c) 2022, Snap Creek LLC
*/
namespace Duplicator\Addons\AmazonS3Addon\Models;
class VultrStorage extends AmazonS3CompatibleStorage
{
/**
* Return the storage type
*
* @return int
*/
public static function getSType()
{
return 12;
}
/**
* Returns the storage type name.
*
* @return string
*/
public static function getStypeName()
{
return __('Vultr', 'duplicator-pro');
}
/**
* Returns the storage type icon url.
*
* @return string The icon url
*/
protected static function getIconUrl()
{
return DUPLICATOR_PRO_IMG_URL . '/vultr.svg';
}
/**
* Return true if the region is generated automatically
*
* @return bool
*/
public function isAutofillRegion()
{
return true;
}
/**
* Get storage location string
*
* @return string
*/
public function getLocationString()
{
return 'https://my.vultr.com/objectstorage/';
}
/**
* Returns the storage location label.
*
* @return string The storage location label
*/
protected function getLocationLabel()
{
return __('Bucket List', 'duplicator-pro');
}
/**
* Get documentation links
*
* @return array<int,array<string,string>>
*/
protected static function getDocumentationLinks()
{
return [
[
'label' => __('Vultr Object Storage', 'duplicator-pro'),
'url' => 'https://www.vultr.com/docs/vultr-object-storage/',
],
];
}
}

91
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/amazons3addon/src/Models/WasabiStorage.php Normal file
View File

@@ -0,0 +1,91 @@
<?php
/**
*
* @package Duplicator
* @copyright (c) 2022, Snap Creek LLC
*/
namespace Duplicator\Addons\AmazonS3Addon\Models;
class WasabiStorage extends AmazonS3CompatibleStorage
{
/**
* Return the storage type
*
* @return int
*/
public static function getSType()
{
return 10;
}
/**
* Returns the storage type name.
*
* @return string
*/
public static function getStypeName()
{
return __('Wasabi', 'duplicator-pro');
}
/**
* Returns the storage type icon url.
*
* @return string The icon url
*/
protected static function getIconUrl()
{
return DUPLICATOR_PRO_IMG_URL . '/wasabi.svg';
}
/**
* Return true if the endpoint is generated automatically
*
* @return bool
*/
public function isAutofillEndpoint()
{
return true;
}
/**
* Get storage location string
*
* @return string
*/
public function getLocationURL()
{
return 'https://console.wasabisys.com/file_manager/';
}
/**
* Returns the storage location label.
*
* @return string The storage location label
*/
protected function getLocationLabel()
{
return __('Bucket List', 'duplicator-pro');
}
/**
* Get documentation links
*
* @return array<int,array<string,string>>
*/
protected static function getDocumentationLinks()
{
return [
[
'label' => __('Wasabi Academy', 'duplicator-pro'),
'url' => 'https://docs.wasabi.com/',
],
[
'label' => __('S3 Compatible API', 'duplicator-pro'),
'url' => 'https://docs.wasabi.com/docs/wasabi-api',
],
];
}
}

104
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/amazons3addon/src/Utils/Autoloader.php Normal file
View File

@@ -0,0 +1,104 @@
<?php
/**
* Auloader calsses
*
* @package Duplicator
* @copyright (c) 2022, Snap Creek LLC
*/
namespace Duplicator\Addons\AmazonS3Addon\Utils;
use Duplicator\Addons\AmazonS3Addon\AmazonS3Addon;
use Duplicator\Utils\AbstractAutoloader;
/**
* Autoloader calss, dont user Duplicator library here
*/
final class Autoloader extends AbstractAutoloader
{
const VENDOR_PATH = AmazonS3Addon::ADDON_PATH . '/vendor-prefixed/';
/**
* Register autoloader function
*
* @return void
*/
public static function register()
{
spl_autoload_register([__CLASS__, 'load']);
self::loadFiles();
}
/**
* Load class
*
* @param string $className class name
*
* @return void
*/
public static function load($className)
{
foreach (self::getNamespacesVendorMapping() as $namespace => $mappedPath) {
if (strpos($className, $namespace) !== 0) {
continue;
}
$filepath = self::getFilenameFromClass($className, $namespace, $mappedPath);
if (file_exists($filepath)) {
include $filepath;
return;
}
}
}
/**
* Load necessary files
*
* @return void
*/
private static function loadFiles()
{
$files = [
'/paragonie/random_compat/lib/random.php',
'/ralouphie/getallheaders/src/getallheaders.php',
'/guzzlehttp/promises/src/functions_include.php',
'/guzzlehttp/psr7/src/functions_include.php',
'/symfony/polyfill-intl-normalizer/bootstrap.php',
'/symfony/polyfill-php70/bootstrap.php',
'/symfony/polyfill-php72/bootstrap.php',
'/symfony/polyfill-intl-idn/bootstrap.php',
'/symfony/polyfill-mbstring/bootstrap.php',
'/guzzlehttp/guzzle/src/functions_include.php',
'/mtdowling/jmespath.php/src/JmesPath.php',
'/aws/aws-sdk-php/src/functions.php',
];
foreach ($files as $file) {
require_once self::VENDOR_PATH . $file;
}
}
/**
* Return namespace mapping
*
* @return string[]
*/
protected static function getNamespacesVendorMapping()
{
return [
self::ROOT_VENDOR . 'Symfony\\Polyfill\\Intl\\Idn' => AmazonS3Addon::getAddonPath() . '/vendor-prefixed/symfony/polyfill-intl-idn',
self::ROOT_VENDOR . 'Symfony\\Polyfill\\Intl\\Normalizer' => AmazonS3Addon::getAddonPath() . '/vendor-prefixed/symfony/polyfill-intl-normalizer',
self::ROOT_VENDOR . 'Symfony\\Polyfill\\Mbstring' => AmazonS3Addon::getAddonPath() . '/vendor-prefixed/symfony/polyfill-mbstring',
self::ROOT_VENDOR . 'Symfony\\Polyfill\\Php70' => AmazonS3Addon::getAddonPath() . '/vendor-prefixed/symfony/polyfill-php70',
self::ROOT_VENDOR . 'Symfony\\Polyfill\\Php72' => AmazonS3Addon::getAddonPath() . '/vendor-prefixed/symfony/polyfill-php72',
self::ROOT_VENDOR . 'JmesPath' => AmazonS3Addon::getAddonPath() . '/vendor-prefixed/mtdowling/jmespath.php/src',
self::ROOT_VENDOR . 'Psr\\Http\\Message' => AmazonS3Addon::getAddonPath() . '/vendor-prefixed/psr/http-message/src',
self::ROOT_VENDOR . 'GuzzleHttp\\Promise' => AmazonS3Addon::getAddonPath() . '/vendor-prefixed/guzzlehttp/promises/src',
self::ROOT_VENDOR . 'GuzzleHttp\\Psr7' => AmazonS3Addon::getAddonPath() . '/vendor-prefixed/guzzlehttp/psr7/src',
self::ROOT_VENDOR . 'GuzzleHttp' => AmazonS3Addon::getAddonPath() . '/vendor-prefixed/guzzlehttp/guzzle/src',
self::ROOT_VENDOR . 'Aws' => AmazonS3Addon::getAddonPath() . '/vendor-prefixed/aws/aws-sdk-php/src',
];
}
}

294
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/amazons3addon/template/amazons3addon/configs/all_s3_compatible.php Normal file
View File

@@ -0,0 +1,294 @@
<?php
/**
* Duplicator messages sections
*
* @package Duplicator
* @copyright (c) 2022, Snap Creek LLC
*/
use Duplicator\Addons\AmazonS3Addon\Models\AmazonS3CompatibleStorage;
defined("ABSPATH") or die("");
/**
* Variables
*
* @var \Duplicator\Core\Controllers\ControllersManager $ctrlMng
* @var \Duplicator\Core\Views\TplMng $tplMng
* @var array<string, mixed> $tplData
* @var AmazonS3CompatibleStorage $storage
*/
$storage = $tplData["storage"];
/** @var int */
$maxPackages = $tplData["maxPackages"];
/** @var string */
$storageFolder = $tplData["storageFolder"];
/** @var string */
$accessKey = $tplData["accessKey"];
/** @var string */
$bucket = $tplData["bucket"];
/** @var string */
$region = $tplData["region"];
/** @var string */
$secretKey = $tplData["secretKey"];
/** @var string */
$storageClass = $tplData["storageClass"];
/** @var string */
$endpoint = $tplData["endpoint"];
/** @var string */
$aclFullControl = $tplData["aclFullControl"];
/** @var bool */
$isAutofillEndpoint = $tplData["isAutofillEndpoint"];
/** @var bool */
$isAutofillRegion = $tplData["isAutofillRegion"];
/** @var bool */
$isAclSupported = $tplData["isAclSupported"];
/** @var string */
$aclDescription = $tplData["aclDescription"];
/** @var array<int,array<string,string>> */
$documentationLinks = $tplData["documentationLinks"];
$tplMng->render('admin_pages/storages/parts/provider_head');
?>
<tr>
<td colspan="2" style="padding-left:0">
<i><?php printf(
esc_html_x(
'S3 Setup Guide: %1$sStep-by-Step%2$s and %3$sUser Bucket Policy%4$s.',
'1%$s and %3$s are opening and %2$s and %4$s are closing <a> tags',
'duplicator-pro'
),
'<a target="_blank" href="' . esc_url(DUPLICATOR_PRO_DUPLICATOR_DOCS_URL . 'amazon-s3-step-by-step') . '">',
'</a>',
'<a href="' . esc_url(DUPLICATOR_PRO_DUPLICATOR_DOCS_URL . 'amazon-s3-policy-setup') . '" target="_blank">',
'</a>'
); ?>
</i>
<i>
<?php if (count($documentationLinks) > 0) {
printf(
esc_html_x(
'Documentation for %s: ',
'%s is the provider name',
'duplicator-pro'
),
esc_html($storage->getStypeName())
);
echo implode(', ', array_map(function ($link) {
return '<a target="_blank" href="' . $link['url'] . '">' . $link['label'] . '</a>';
}, $documentationLinks));
} ?>
</i>
</td>
</tr>
<tr>
<th scope="row"><label for=""><?php esc_html_e("Authorization", 'duplicator-pro'); ?></label></th>
<td class="dup-s3-auth-account">
<h3>
<?php
if ($storage->getId() < 0) {
echo $storage->getStypeIcon();
}
?>
<?php echo esc_html($storage->getStypeName()) . ' ' . esc_html__('Account', 'duplicator-pro'); ?>
</h3>
<?php if ($storage->getSType() === AmazonS3CompatibleStorage::getSType()) {
$tplMng->render('amazons3addon/parts/s3_compatible_msg');
} ?>
<table class="dup-form-sub-area margin-top-1">
<tr>
<th scope="row">
<label for="s3_access_key_<?php echo (int) $storage->getSType(); ?>">
<?php echo esc_html($storage->getFieldLabel('accessKey')); ?>:
</label>
</th>
<td>
<input
id="s3_access_key_<?php echo (int) $storage->getSType(); ?>"
name="s3_access_key"
data-parsley-errors-container="#s3_access_key_<?php echo (int) $storage->getSType(); ?>_error_container"
type="text"
autocomplete="off"
value="<?php echo esc_attr($accessKey); ?>"
data-parsley-required="true"
>
<div id="s3_access_key_<?php echo (int) $storage->getSType(); ?>_error_container" class="duplicator-error-container"></div>
</td>
</tr>
<tr>
<th scope="row">
<label for="s3_secret_key_<?php echo (int) $storage->getSType(); ?>">
<?php echo esc_html($storage->getFieldLabel('secretKey')); ?>:
</label>
</th>
<td>
<input
id="s3_secret_key_<?php echo (int) $storage->getSType(); ?>"
name="s3_secret_key"
type="password"
placeholder="<?php echo esc_attr(str_repeat("*", strlen($secretKey))); ?>"
data-parsley-errors-container="#s3_secret_key_<?php echo (int) $storage->getSType(); ?>_error_container"
autocomplete="off"
value=""
>
<div id="s3_secret_key_<?php echo (int) $storage->getSType(); ?>_error_container" class="duplicator-error-container"></div>
</td>
</tr>
</table>
</td>
</tr>
<tr>
<th scope="row"></th>
<td>
<table class="dup-form-sub-area dup-s3-auth-provider">
<tr>
<th>
<label for="s3_endpoint_<?php echo (int) $storage->getSType(); ?>">
<?php echo esc_html($storage->getFieldLabel('endpoint')); ?>:
</label>
</th>
<td>
<input
type="text"
id="s3_endpoint_<?php echo (int) $storage->getSType(); ?>"
name="s3_endpoint"
value="<?php echo esc_attr($endpoint); ?>"
<?php echo ($isAutofillEndpoint ? 'readonly="true"' : ''); ?>
data-parsley-required="true"
>
<?php if ($isAutofillEndpoint) : ?>
<p class="description">
<i><?php esc_html_e('The endpoint URL will be autofilled based on the region.', 'duplicator-pro'); ?></i>
</p>
<?php endif; ?>
</td>
</tr>
<tr>
<th>
<label for="s3_region_<?php echo (int) $storage->getSType(); ?>">
<?php echo esc_html($storage->getFieldLabel('region')); ?>:
</label>
</th>
<td>
<input
type="text"
id="s3_region_<?php echo (int) $storage->getSType(); ?>"
name="s3_region"
<?php echo ($isAutofillRegion ? 'readonly="true"' : ''); ?>
value="<?php echo esc_attr($region); ?>"
data-parsley-required="true"
data-parsley-pattern="[0-9a-zA-Z-_]+"
>
<?php if ($isAutofillRegion) : ?>
<p class="description">
<i><?php esc_html_e('The region will be autodetected from the endpoint URL.', 'duplicator-pro'); ?></i>
</p>
<?php endif; ?>
</td>
</tr>
<tr class="invisible_out_of_screen">
<th>
<label for="s3_storage_class_<?php echo (int) $storage->getSType(); ?>">
<?php esc_html_e("Storage Class", 'duplicator-pro'); ?>:
</label>
</th>
<td>
<select id="s3_storage_class_<?php echo (int) $storage->getSType(); ?>" name="s3_storage_class">
<option <?php selected(true); ?> value="STANDARD"><?php esc_html_e("Standard", 'duplicator-pro'); ?></option>
</select>
</td>
</tr>
<tr>
<th scope="row">
<label for="s3_bucket_<?php echo (int) $storage->getSType(); ?>">
<?php echo esc_html($storage->getFieldLabel('bucket')); ?>
</label>
</th>
<td>
<input
id="s3_bucket_<?php echo (int) $storage->getSType(); ?>"
name="s3_bucket"
type="text"
value="<?php echo esc_attr($bucket); ?>"
data-parsley-required="true"
>
<p class="description">
<i><?php esc_html_e("S3 Bucket where you want to save the backups.", 'duplicator-pro'); ?></i>
</p>
</td>
</tr>
</table>
</td>
</tr>
<tr>
<th><label for="_s3_storage_folder_<?php echo (int) $storage->getSType(); ?>"><?php esc_html_e("Storage Folder", 'duplicator-pro'); ?>:</label></th>
<td>
<input
id="_s3_storage_folder_<?php echo (int) $storage->getSType(); ?>"
name="_s3_storage_folder"
type="text"
value="<?php echo esc_attr($storageFolder); ?>"
>
<p class="description">
<i>
<?php
esc_html_e(
"Folder where packages will be stored. This should be unique for each web-site using Duplicator.",
'duplicator-pro'
);
?>
</i>
</p>
</td>
</tr>
<tr>
<th scope="row"><label for="s3_max_files_<?php echo (int) $storage->getSType(); ?>"><?php esc_html_e("Max Packages", 'duplicator-pro'); ?></label></th>
<td>
<label for="s3_max_files_<?php echo (int) $storage->getSType(); ?>">
<input
id="s3_max_files_<?php echo (int) $storage->getSType(); ?>"
class="s3_max_files"
name="s3_max_files"
type="number"
value="<?php echo (int) $maxPackages; ?>"
min="0"
maxlength="4"
data-parsley-errors-container="#s3_max_files_<?php echo (int) $storage->getSType(); ?>_error_container"
data-parsley-required="true"
data-parsley-type="number"
data-parsley-min="0"
>
<?php esc_html_e("Number of packages to keep in folder.", 'duplicator-pro'); ?>
<p class="description">
<i><?php esc_html_e("When this limit is exceeded, the oldest package will be deleted. Set to 0 for no limit.", 'duplicator-pro'); ?></i>
</p>
</label>
<div id="s3_max_files_<?php echo (int) $storage->getSType(); ?>_error_container" class="duplicator-error-container"></div>
</td>
</tr>
<?php if ($isAclSupported) : ?>
<tr class="s3-acl-row" valign="top">
<th scope="row"><label><?php echo esc_html($storage->getFieldLabel('aclFullControl')); ?></label></th>
<td>
<input
type="checkbox"
name="s3_ACL_full_control"
id="s3_ACL_full_control_<?php echo (int) $storage->getSType(); ?>"
value="1"
<?php checked($aclFullControl, true); ?>
>
<label for="s3_ACL_full_control_<?php echo (int) $storage->getSType(); ?>">
<?php esc_html_e("Give bucket owner full control (ACL) to all files uploaded by Duplicator Pro.", 'duplicator-pro'); ?>
</label><br />
<p class="description">
<i>
<?php echo esc_html($aclDescription); ?>
</i>
</p>
</td>
</tr>
<?php endif; ?>
<?php $tplMng->render('admin_pages/storages/parts/provider_foot');

199
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/amazons3addon/template/amazons3addon/configs/amazon_s3.php Normal file
View File

@@ -0,0 +1,199 @@
<?php
/**
* Duplicator messages sections
*
* @package Duplicator
* @copyright (c) 2022, Snap Creek LLC
*/
use Duplicator\Addons\AmazonS3Addon\Models\AmazonS3Storage;
defined("ABSPATH") or die("");
/**
* Variables
*
* @var \Duplicator\Core\Controllers\ControllersManager $ctrlMng
* @var \Duplicator\Core\Views\TplMng $tplMng
* @var array<string, mixed> $tplData
* @var AmazonS3Storage $storage
*/
$storage = $tplData["storage"];
/** @var int */
$maxPackages = $tplData["maxPackages"];
/** @var string */
$storageFolder = $tplData["storageFolder"];
/** @var string */
$accessKey = $tplData["accessKey"];
/** @var string */
$bucket = $tplData["bucket"];
/** @var string */
$region = $tplData["region"];
/** @var string */
$secretKey = $tplData["secretKey"];
/** @var string */
$storageClass = $tplData["storageClass"];
/** @var string */
$endpoint = $tplData["endpoint"];
/** @var string */
$aclFullControl = $tplData["aclFullControl"];
/** @var array<string,string> */
$regionOptions = $tplData["regionOptions"];
$tplMng->render('admin_pages/storages/parts/provider_head');
?>
<tr>
<td colspan="2" style="padding-left:0">
<i>
<?php
printf(
esc_html_x(
'Amazon S3 Setup Guide: %1$sStep-by-Step%2$s and %3$sUser Bucket Policy%4$s.',
'1,3 represents <a> tag, 2,4 represents </a> tag',
'duplicator-pro'
),
'<a target="_blank" href="' . esc_url(DUPLICATOR_PRO_DUPLICATOR_DOCS_URL . 'amazon-s3-step-by-step') . '">',
'</a>',
'<a href="' . esc_url(DUPLICATOR_PRO_DUPLICATOR_DOCS_URL . 'amazon-s3-policy-setup') . '" target="_blank">',
'</a>'
);
?>
</i>
</td>
</tr>
<tr>
<th scope="row"><label for=""><?php esc_html_e("Authorization", 'duplicator-pro'); ?></label></th>
<td class="dup-s3-auth-account">
<h3>
<?php esc_html_e('Amazon Account', 'duplicator-pro'); ?><br/>
</h3>
<table class="dup-form-sub-area">
<tr>
<th scope="row"><label for="s3_access_key_amazon"><?php esc_html_e("Access Key", 'duplicator-pro'); ?>:</label></th>
<td>
<input
id="s3_access_key_amazon"
name="s3_access_key"
data-parsley-errors-container="#s3_access_key_amazon_error_container"
type="text"
autocomplete="off"
value="<?php echo esc_attr($accessKey); ?>"
>
<div id="s3_access_key_amazon_error_container" class="duplicator-error-container"></div>
</td>
</tr>
<tr>
<th scope="row">
<label for="s3_secret_key_amazon"><?php esc_html_e("Secret Key", 'duplicator-pro'); ?>:</label>
</th>
<td>
<input
id="s3_secret_key_amazon"
name="s3_secret_key"
type="password"
placeholder="<?php echo esc_attr(str_repeat("*", strlen($secretKey))); ?>"
data-parsley-errors-container="#s3_secret_key_amazon_error_container"
autocomplete="off"
value=""
>
<div id="s3_secret_key_amazon_error_container" class="duplicator-error-container"></div>
</td>
</tr>
</table>
</td>
</tr>
<tr>
<th scope="row"></th>
<td>
<table class="dup-form-sub-area dup-s3-auth-provider">
<tr>
<th><label for="s3_region_amazon"><?php esc_html_e("Region", 'duplicator-pro'); ?>:</label></th>
<td>
<select id="s3_region_amazon" name="s3_region">
<?php
foreach ($regionOptions as $value => $label) {
?>
<option
<?php selected($region, $value); ?>
value="<?php echo esc_attr($value); ?>"
>
<?php echo esc_html($label . " - '" . $value . "'"); ?>
</option>
<?php
}
?>
</select>
</td>
</tr>
<tr>
<th><label for="s3_storage_class_amazon"><?php esc_html_e("Storage Class", 'duplicator-pro'); ?>:</label></th>
<td>
<select id="s3_storage_class_amazon" name="s3_storage_class">
<option <?php selected($storageClass == 'REDUCED_REDUNDANCY'); ?> value="REDUCED_REDUNDANCY">
<?php esc_html_e("Reduced Redundancy", 'duplicator-pro'); ?>
</option>
<option <?php selected($storageClass == 'STANDARD'); ?> value="STANDARD">
<?php esc_html_e("Standard", 'duplicator-pro'); ?>
</option>
<option <?php selected($storageClass == 'STANDARD_IA'); ?> value="STANDARD_IA">
<?php esc_html_e("Standard IA", 'duplicator-pro'); ?>
</option>
</select>
</td>
</tr>
<tr>
<th><label for="_s3_storage_folder_amazon"><?php esc_html_e("Storage Folder", 'duplicator-pro'); ?>:</label></th>
<td>
<input
id="_s3_storage_folder_amazon"
name="_s3_storage_folder"
type="text"
value="<?php echo esc_attr($storageFolder); ?>"
>
<p>
<i>
<?php esc_html_e(
"Folder where packages will be stored. This should be unique for each web-site using Duplicator.",
'duplicator-pro'
); ?>
</i>
</p>
</td>
</tr>
</table>
</td>
</tr>
<tr>
<th scope="row"><label for="s3_bucket_amazon"><?php esc_html_e("Bucket", 'duplicator-pro'); ?></label></th>
<td>
<input id="s3_bucket_amazon" name="s3_bucket" type="text" value="<?php echo esc_attr($bucket); ?>">
<p><i><?php esc_html_e("S3 Bucket where you want to save the backups.", 'duplicator-pro'); ?></i></p>
</td>
</tr>
<tr>
<th scope="row"><label for="s3_max_files_amazon"><?php esc_html_e("Max Packages", 'duplicator-pro'); ?></label></th>
<td>
<label for="s3_max_files_amazon">
<input
id="s3_max_files_amazon"
class="s3_max_files"
name="s3_max_files"
type="number"
value="<?php echo (int) $maxPackages; ?>"
min="0"
maxlength="4"
data-parsley-errors-container="#s3_max_files_amazon_error_container"
data-parsley-required="true"
data-parsley-type="number"
data-parsley-min="0"
>
<?php esc_html_e("Number of packages to keep in folder.", 'duplicator-pro'); ?><br/>
<i><?php esc_html_e("When this limit is exceeded, the oldest package will be deleted. Set to 0 for no limit.", 'duplicator-pro'); ?></i>
</label>
<div id="s3_max_files_amazon_error_container" class="duplicator-error-container"></div>
</td>
</tr>
<?php $tplMng->render('admin_pages/storages/parts/provider_foot'); ?>

43
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/amazons3addon/template/amazons3addon/parts/s3_compatible_msg.php Normal file
View File

@@ -0,0 +1,43 @@
<?php
/**
* @package Duplicator
* @copyright (c) 2022, Snap Creek LLC
*/
use Duplicator\Models\Storages\AbstractStorageEntity;
use Duplicator\Addons\AmazonS3Addon\Models\AmazonS3CompatibleStorage;
defined("ABSPATH") or die("");
/**
* Variables
*
* @var \Duplicator\Core\Controllers\ControllersManager $ctrlMng
* @var \Duplicator\Core\Views\TplMng $tplMng
* @var array<string, mixed> $tplData
* @var AbstractStorageEntity $storage
*/
$storage = $tplData["storage"];
?>
<p>
<?php
esc_html_e(
'The Amazon S3 compatible storage option allows you to connect to any object storage that is compatible with the S3 API.',
'duplicator-pro'
);
?>
</p>
<p>
<?php
printf(
esc_attr_x(
'Examples of compatible providers are %s.',
'%s is a comma seperated list of providers',
'duplicator-pro'
),
'<b>' . esc_html(implode(', ', AmazonS3CompatibleStorage::getCompatibleProviders())) . '</b>'
);
?>
</p>

93
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/dropboxaddon/DropboxAddon.php Normal file
View File

@@ -0,0 +1,93 @@
<?php
namespace Duplicator\Addons\DropboxAddon;
use Duplicator\Addons\DropboxAddon\Models\DropboxStorage;
use Duplicator\Addons\DropboxAddon\Utils\Autoloader;
use Duplicator\Core\Addons\AbstractAddonCore;
use Duplicator\Models\Storages\AbstractStorageEntity;
class DropboxAddon extends AbstractAddonCore
{
const ADDON_PATH = __DIR__;
/**
* @return void
*/
public function init()
{
Autoloader::register();
add_action('duplicator_pro_register_storage_types', [$this, 'registerStorages']);
add_filter('duplicator_template_file', array(__CLASS__, 'getTemplateFile'), 10, 2);
add_filter('duplicator_usage_stats_storages_infos', array(__CLASS__, 'getStorageUsageStats'), 10);
}
/**
* Return template file path
*
* @param string $path path to the template file
* @param string $slugTpl slug of the template
*
* @return string
*/
public static function getTemplateFile($path, $slugTpl)
{
if (strpos($slugTpl, 'dropboxaddon/') === 0) {
return self::getAddonPath() . '/template/' . $slugTpl . '.php';
}
return $path;
}
/**
* Get storage usage stats
*
* @param array<string,int> $storageNums Storages num
*
* @return array<string,int>
*/
public static function getStorageUsageStats($storageNums)
{
if (($storages = AbstractStorageEntity::getAll()) === false) {
$storages = [];
}
$storageNums['storages_dropbox_count'] = 0;
foreach ($storages as $storage) {
if ($storage->getSType() === DropboxStorage::getSType()) {
$storageNums['storages_dropbox_count']++;
}
}
return $storageNums;
}
/**
* Register storages
*
* @return void
*/
public function registerStorages()
{
DropboxStorage::registerType();
}
/**
*
* @return string
*/
public static function getAddonPath()
{
return self::ADDON_PATH;
}
/**
*
* @return string
*/
public static function getAddonFile()
{
return __FILE__;
}
}

527
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/dropboxaddon/src/Models/DropboxAdapter.php Normal file
View File

@@ -0,0 +1,527 @@
<?php
namespace Duplicator\Addons\DropboxAddon\Models;
use Duplicator\Addons\DropboxAddon\Utils\DropboxClient;
use Duplicator\Models\Storages\AbstractStorageAdapter;
use Duplicator\Models\Storages\StoragePathInfo;
use VendorDuplicator\Dropbox\Spatie\Dropbox\UploadSessionCursor;
class DropboxAdapter extends AbstractStorageAdapter
{
/** @var string */
protected $accessToken = '';
/** @var DropboxClient */
protected $client = null;
/** @var string */
protected $storageFolder = '';
/** @var bool */
protected $sslVerify = true;
/** @var string If empty use server cert else use custom cert path */
protected $sslCert = '';
/** @var bool */
protected $ipv4Only = false;
/**
* @param string $accessToken Dropbox access token.
* @param string $storageFolder Dropbox storage folder.
* @param bool $sslVerify If true, use SSL
* @param string $sslCert If empty use server cert
* @param bool $ipv4Only If true, use IPv4 only
*/
public function __construct(
$accessToken,
$storageFolder = '',
$sslVerify = true,
$sslCert = '',
$ipv4Only = false
) {
$this->accessToken = $accessToken;
$this->storageFolder = '/' . trim($storageFolder, '/') . '/';
$this->sslVerify = $sslVerify;
$this->sslCert = $sslCert;
$this->ipv4Only = $ipv4Only;
$this->client = new DropboxClient($accessToken, null, DropboxClient::MAX_CHUNK_SIZE, 0, $sslVerify, $sslCert, $ipv4Only);
}
/**
* Get the Dropbox client.
*
* @return DropboxClient
*/
public function getClient()
{
return $this->client;
}
/**
* Initialize the storage on creation.
*
* @param string $errorMsg The error message if storage is invalid.
*
* @return bool true on success or false on failure.
*/
public function initialize(&$errorMsg = '')
{
if (! $this->exists('/')) {
try {
$this->createDir('/');
} catch (\Exception $e) {
\DUP_PRO_Log::trace($e->getMessage());
$errorMsg = $e->getMessage();
return false;
}
}
return true;
}
/**
* Destroy the storage on deletion.
*
* @return bool true on success or false on failure.
*/
public function destroy()
{
$this->delete('/', true);
return true;
}
/**
* Check if storage is valid and ready to use.
*
* @param string $errorMsg The error message if storage is invalid.
*
* @return bool
*/
public function isValid(&$errorMsg = '')
{
try {
$this->client->getMetadata($this->storageFolder);
} catch (\Exception $e) {
\DUP_PRO_Log::trace("Dropbox storage is invalid: " . $e->getMessage());
$errorMsg = $e->getMessage();
return false;
}
return true;
}
/**
* Create the directory specified by pathname, recursively if necessary.
*
* @param string $path The directory path.
*
* @return bool true on success or false on failure.
*/
protected function realCreateDir($path)
{
$path = $this->formatPath($path);
try {
$this->client->createFolder($path);
} catch (\Exception $e) {
\DUP_PRO_Log::trace($e->getMessage());
return false;
}
return true;
}
/**
* Create file with content.
*
* @param string $path The path to file.
* @param string $content The content of file.
*
* @return false|int The number of bytes that were written to the file, or false on failure.
*/
protected function realCreateFile($path, $content)
{
$path = $this->formatPath($path);
try {
$response = $this->client->upload($path, $content, 'overwrite');
} catch (\Exception $e) {
\DUP_PRO_Log::trace($e->getMessage());
return false;
}
return $response['size'];
}
/**
* Delete relative path from storage root.
*
* @param string $path The path to delete. (Accepts directories and files)
* @param bool $recursive Allows the deletion of nested directories specified in the pathname. Default to false.
*
* @return bool true on success or false on failure.
*/
protected function realDelete($path, $recursive = false)
{
$path = $this->formatPath($path);
if (! $recursive) {
try {
$response = $this->client->listFolder($path);
if (count($response['entries']) > 0) {
return false;
}
} catch (\Exception $e) {
// Path is not a directory, so we can delete it.
}
}
try {
$this->client->delete($path);
} catch (\Exception $e) {
\DUP_PRO_Log::trace($e->getMessage());
return false;
}
return true;
}
/**
* Get file content.
*
* @param string $path The path to file.
*
* @return string|false The content of file or false on failure.
*/
public function getFileContent($path)
{
$content = '';
try {
$stream = $this->client->download($this->formatPath($path));
while ($chunk = fgets($stream)) {
$content .= $chunk;
}
} catch (\Exception $e) {
\DUP_PRO_Log::trace($e->getMessage());
return false;
}
return $content;
}
/**
* Move and/or rename a file or directory.
*
* @param string $oldPath Relative storage path
* @param string $newPath Relative storage path
*
* @return bool true on success or false on failure.
*/
protected function realMove($oldPath, $newPath)
{
$oldPath = $this->formatPath($oldPath);
$newPath = $this->formatPath($newPath);
try {
$this->client->move($oldPath, $newPath);
} catch (\Exception $e) {
\DUP_PRO_Log::trace($e->getMessage());
return false;
}
return true;
}
/**
* Get path info.
*
* @param string $path Relative storage path, if empty, return root path info.
*
* @return StoragePathInfo The path info or false if path is invalid.
*/
protected function getRealPathInfo($path)
{
try {
$response = $this->client->getMetadata($this->formatPath($path));
} catch (\Exception $e) {
$response = [];
}
return $this->buildPathInfo($response);
}
/**
* Get the list of files and directories inside the specified path.
*
* @param string $path Relative storage path, if empty, scan root path.
* @param bool $files If true, add files to the list. Default to true.
* @param bool $folders If true, add folders to the list. Default to true.
*
* @return string[] The list of files and directories, empty array if path is invalid.
*/
public function scanDir($path, $files = true, $folders = true)
{
$path = rtrim($this->formatPath($path), '/') . '/';
$filterFunc = function ($entry) use ($files, $folders) {
if ($entry['.tag'] === 'file' && $files) {
return true;
}
if ($entry['.tag'] === 'folder' && $folders) {
return true;
}
return false;
};
try {
$response = $this->client->listFolder($path);
} catch (\Exception $e) {
\DUP_PRO_Log::trace('[DropboxAddon] ' . $e->getMessage());
return [];
}
// We filter out the entries as needed, then only keep the path.
// We do this early to keep the memory usage as low as possible.
$entries = array_map(function ($entry) use ($path) {
return substr($entry['path_display'], strlen($path));
}, array_filter($response['entries'], $filterFunc));
while ($response['has_more']) {
$response = $this->client->listFolderContinue($response['cursor']);
$entries = array_merge($entries, array_map(function ($entry) use ($path) {
return substr($entry['path_display'], strlen($path));
}, array_filter($response['entries'], $filterFunc)));
}
return $entries;
}
/**
* Check if directory is empty.
*
* @param string $path The folder path
* @param string[] $filters Filters to exclude files and folders from the check, if start and end with /, use regex.
*
* @return bool True is ok, false otherwise
*/
public function isDirEmpty($path, $filters = [])
{
$path = $this->formatPath($path);
try {
$response = $this->client->listFolder($path);
} catch (\Exception $e) {
\DUP_PRO_Log::trace($e->getMessage());
return false;
}
if (count($response['entries']) === 0) {
return true;
} elseif (empty($filters)) {
// we have no filters, and the folder is not empty, so it must contain something
return false;
}
$regexFilters = $normalFilters = [];
foreach ($filters as $filter) {
if ($filter[0] === '/' && substr($filter, -1) === '/') {
$regexFilters[] = $filter; // It's a regex filter as it starts and ends with a slash
} else {
$normalFilters[] = $filter;
}
}
$contents = $this->scanDir($path);
foreach ($contents as $item) {
if (in_array($item, $normalFilters)) {
continue;
}
foreach ($regexFilters as $regexFilter) {
if (preg_match($regexFilter, $item) === 1) {
continue 2;
}
}
return false;
}
return true;
}
/**
* Copy local file to storage, partial copy is supported.
* If destination file exists, it will be overwritten.
* If offset is less than the destination file size, the file will be truncated.
*
* @param string $sourceFile The source file full path
* @param string $storageFile Storage destination path
* @param int<0,max> $offset The offset where the data starts.
* @param int $length The maximum number of bytes read. Default to -1 (read all the remaining buffer).
* @param int $timeout The timeout for the copy operation in microseconds. Default to 0 (no timeout).
* @param array<string,mixed> $extraData Extra data to pass to copy function and updated during copy.
* Used for storages that need to maintain persistent data during copy intra-session.
*
* @return false|int The number of bytes that were written to the file, or false on failure.
*/
protected function realCopyToStorage($sourceFile, $storageFile, $offset = 0, $length = -1, $timeout = 0, &$extraData = [])
{
$storageFile = $this->formatPath($storageFile);
if (!$handle = fopen($sourceFile, 'rb')) {
\DUP_PRO_Log::trace("[DropboxAddon] Could not open source file: {$sourceFile}");
return false;
}
fseek($handle, $offset);
$chunkSize = $length > 0 ? $length : MB_IN_BYTES;
if (!empty($extraData['sessionId'])) {
$sessionId = $extraData['sessionId'];
$cursor = new UploadSessionCursor($sessionId, $offset);
} else {
// We need to start a new session.
try {
$contents = fread($handle, $chunkSize);
$cursor = $this->client->uploadSessionStart($contents);
$extraData['sessionId'] = $cursor->session_id;
} catch (\Exception $e) {
\DUP_PRO_Log::trace($e->getMessage());
return false;
}
}
\DUP_PRO_Log::info("[Dropbox] Setting timeout for upload request for: {$storageFile} to " . ($timeout / SECONDS_IN_MICROSECONDS) . " seconds");
$this->client->setTimeout($timeout / SECONDS_IN_MICROSECONDS);
while (($contents = fread($handle, $chunkSize)) && ($length < 0 || $offset > 0)) {
try {
$this->client->uploadSessionAppend($contents, $cursor);
} catch (\Exception $e) {
unset($extraData['sessionId']);
$this->client->setTimeout(0);
\DUP_PRO_Log::trace('[DropboxAddon] ' . $e->getMessage());
return false;
}
if ($length > 0) {
// A specific length was requested, so we can break out of the loop.
break;
}
}
$fileSize = filesize($sourceFile);
$this->client->setTimeout(0);
\DUP_PRO_Log::info("[Dropbox] uploaded {$storageFile} from {$offset} to {$cursor->offset}, progress: " . ceil($cursor->offset / $fileSize * 100) . "%");
// If we have finished uploading, we need to finish the session & clear the cache
if ($cursor->offset >= $fileSize) {
try {
\DUP_PRO_Log::info("[DropboxAddon] Finishing upload request for: {$storageFile}");
$this->client->uploadSessionFinish('', $cursor, $storageFile, 'overwrite'); // this will return the file metadata
} catch (\Exception $e) {
\DUP_PRO_Log::trace('[DropboxAddon] ' . $e->getMessage());
return false;
}
unset($extraData['sessionId']);
}
return $length > 0 ? $length : $fileSize;
}
/**
* Normalize path, add storage root path if needed.
*
* @param string $path Relative storage path.
*
* @return string
*/
protected function formatPath($path)
{
return $this->storageFolder . ltrim($path, '/');
}
/**
* Build StoragePathInfo object from Dropbox API response.
*
* @param array<string,mixed> $response Dropbox API response.
*
* @return StoragePathInfo
*/
protected function buildPathInfo($response)
{
$info = new StoragePathInfo();
$info->exists = isset($response['.tag']);
if (!$info->exists) {
return $info;
}
$info->path = $this->getRelativeStoragePath($response['path_display']);
$info->isDir = $response['.tag'] === 'folder';
$info->size = isset($response['size']) ? $response['size'] : 0;
$info->created = isset($response['client_modified']) ? strtotime($response['client_modified']) : time();
$info->modified = isset($response['server_modified']) ? strtotime($response['server_modified']) : time();
return $info;
}
/**
* Get relative storage path from Dropbox path display.
*
* @param string $path_display Dropbox path display.
* @param string $subPath Sub path to remove from the path display.
*
* @return string
*/
protected function getRelativeStoragePath($path_display, $subPath = '')
{
$rootPath = $this->storageFolder;
if (!empty($subPath)) {
$rootPath .= trim($subPath) . '/';
}
return substr($path_display, strlen($rootPath));
}
/**
* Copy storage file to local file, partial copy is supported.
* If destination file exists, it will be overwritten.
* If offset is less than the destination file size, the file will be truncated.
*
* @param string $storageFile The storage file path
* @param string $destFile The destination local file full path
* @param int<0,max> $offset The offset where the data starts.
* @param int $length The maximum number of bytes read. Default to -1 (read all the remaining buffer).
* @param int $timeout The timeout for the copy operation in microseconds. Default to 0 (no timeout).
* @param array<string,mixed> $extraData Extra data to pass to copy function and updated during copy.
* Used for storages that need to maintain persistent data during copy intra-session.
*
* @return false|int The number of bytes that were written to the file, or false on failure.
*/
public function copyFromStorage($storageFile, $destFile, $offset = 0, $length = -1, $timeout = 0, &$extraData = [])
{
if (! $this->exists($storageFile)) {
\DUP_PRO_Log::trace("[DropboxAddon] Storage file {$storageFile} does not exist");
return false;
}
if (! isset($extraData['resuming']) && file_put_contents($destFile, '') === false) {
\DUP_PRO_Log::trace("[DropboxAddon] Could not open destination file for writing. File: {$destFile}");
return false;
}
$extraData['resuming'] = true;
$this->client->setTimeout($timeout / SECONDS_IN_MICROSECONDS);
$resource = $this->client->download($this->formatPath($storageFile));
if (! $resource) {
$this->client->setTimeout(0);
\DUP_PRO_Log::trace("[DropboxAddon] Could not open storage file for downloading. File: {$storageFile}");
return false;
}
fseek($resource, $offset);
$content = '';
while (!feof($resource)) {
$content .= fread($resource, $length > 0 ? $length : MB_IN_BYTES);
if ($length > 0 && strlen($content) > $length) {
$content = substr($content, 0, $length);
break;
}
}
$this->client->setTimeout(0);
if (file_put_contents($destFile, $content, FILE_APPEND) !== false) {
return $length < 0 ? strlen($content) : $length;
}
return false;
}
}

595
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/dropboxaddon/src/Models/DropboxStorage.php Normal file
View File

@@ -0,0 +1,595 @@
<?php
/**
*
* @package Duplicator
* @copyright (c) 2022, Snap Creek LLC
*/
namespace Duplicator\Addons\DropboxAddon\Models;
use DUP_PRO_Dropbox_Transfer_Mode;
use DUP_PRO_Global_Entity;
use DUP_PRO_Log;
use Duplicator\Addons\DropboxAddon\Utils\DropboxClient;
use Duplicator\Core\Views\TplMng;
use Duplicator\Libs\Snap\SnapUtil;
use Duplicator\Models\DynamicGlobalEntity;
use Duplicator\Models\Storages\AbstractStorageEntity;
use Duplicator\Models\Storages\StorageAuthInterface;
use Duplicator\Utils\Crypt\CryptBlowfish;
use Exception;
/**
* @property DropboxAdapter $adapter
*/
class DropboxStorage extends AbstractStorageEntity implements StorageAuthInterface
{
/**
* Get default config
*
* @return array<string,scalar>
*/
protected static function getDefaultConfig()
{
$config = parent::getDefaultConfig();
return array_merge(
$config,
[
'access_token' => '',
'access_token_secret' => '',
'v2_access_token' => '',
'authorized' => false,
]
);
}
/**
* Serialize
*
* Wakeup method.
*
* @return void
*/
public function __wakeup()
{
parent::__wakeup();
if ($this->legacyEntity) {
// Old storage entity
$this->legacyEntity = false;
// Make sure the storage type is right from the old entity
$this->storage_type = $this->getSType();
$this->config = [
'access_token' => $this->dropbox_access_token,
'access_token_secret' => $this->dropbox_access_token_secret,
'v2_access_token' => $this->dropbox_v2_access_token,
'storage_folder' => ltrim($this->dropbox_storage_folder, '/\\'),
'max_packages' => $this->dropbox_max_files,
'authorized' => ($this->dropbox_authorization_state == 4),
];
// reset old values
$this->dropbox_access_token = '';
$this->dropbox_access_token_secret = '';
$this->dropbox_v2_access_token = '';
$this->dropbox_storage_folder = '';
$this->dropbox_max_files = 10;
$this->dropbox_authorization_state = 0;
}
}
/**
* Return the storage type
*
* @return int
*/
public static function getSType()
{
return 1;
}
/**
* Returns the storage type icon.
*
* @return string Returns the storage icon
*/
public static function getStypeIcon()
{
return '<img src="' . esc_url(DUPLICATOR_PRO_IMG_URL . '/dropbox.svg') . '" class="dup-storage-icon" alt="' . esc_attr(static::getStypeName()) . '" />';
}
/**
* Returns the storage type name.
*
* @return string
*/
public static function getStypeName()
{
return __('Dropbox', 'duplicator-pro');
}
/**
* Get storage location string
*
* @return string
*/
public function getLocationString()
{
$dropBoxInfo = $this->getAccountInfo();
if (!isset($dropBoxInfo['locale']) || $dropBoxInfo['locale'] == 'en') {
return "https://dropbox.com/home/Apps/Duplicator%20Pro/" . ltrim($this->getStorageFolder(), '/');
} else {
return "https://dropbox.com/home";
}
}
/**
* Check if storage is valid
*
* @return bool Return true if storage is valid and ready to use, false otherwise
*/
public function isValid()
{
return $this->isAuthorized();
}
/**
* Is autorized
*
* @return bool
*/
public function isAuthorized()
{
return $this->config['authorized'];
}
/**
* Authorized from HTTP request
*
* @param string $message Message
*
* @return bool True if authorized, false if failed
*/
public function authorizeFromRequest(&$message = '')
{
try {
if (($authCode = SnapUtil::sanitizeTextInput(SnapUtil::INPUT_REQUEST, 'auth_code')) === '') {
throw new Exception(__('Authorization code is empty', 'duplicator-pro'));
}
$this->name = SnapUtil::sanitizeTextInput(SnapUtil::INPUT_REQUEST, 'name', '');
$this->notes = SnapUtil::sanitizeDefaultInput(SnapUtil::INPUT_REQUEST, 'notes', '');
$this->config['max_packages'] = SnapUtil::sanitizeIntInput(SnapUtil::INPUT_REQUEST, 'max_packages', 10);
$this->config['storage_folder'] = self::getSanitizedInputFolder('storage_folder', 'remove');
$this->revokeAuthorization();
$client = $this->getAdapter()->getClient();
if (($token = $client->authenticate($authCode, self::getApiKeySecret())) === false) {
throw new Exception(__("Couldn't connect. Dropbox access token not found.", 'duplicator-pro'));
}
$this->config['v2_access_token'] = $token;
$this->config['authorized'] = true;
} catch (Exception $e) {
DUP_PRO_Log::trace("Problem authorizing Dropbox access token msg: " . $e->getMessage());
$message = $e->getMessage();
return false;
}
$message = __('Dropbox is connected successfully and Storage Provider Updated.', 'duplicator-pro');
return true;
}
/**
* Revokes authorization
*
* @param string $message Message
*
* @return bool True if authorized, false if failed
*/
public function revokeAuthorization(&$message = '')
{
if (!$this->isAuthorized()) {
$message = __('Dropbox isn\'t authorized.', 'duplicator-pro');
return true;
}
try {
$client = $this->getAdapter()->getClient();
if ($client->revokeToken() === false) {
throw new Exception(__('DropBox can\'t be unauthorized.', 'duplicator-pro'));
}
$this->config['v2_access_token'] = '';
$this->config['authorized'] = false;
} catch (Exception $e) {
DUP_PRO_Log::trace("Problem revoking Dropbox access token msg: " . $e->getMessage());
$message = $e->getMessage();
return false;
}
$message = __('Dropbox is disconnected successfully.', 'duplicator-pro');
return true;
}
/**
* Get authorization URL
*
* @todo: This should be refactored to use the new TokenService class.
*
* @return string
*/
public function getAuthorizationUrl()
{
$config = self::getApiKeySecret();
return DropboxClient::OAUTH2_URL . 'authorize?client_id=' . $config['app_key'] . '&response_type=code';
}
/**
* Get action key text
*
* @param string $key Key name (action, pending, failed, cancelled, success)
*
* @return string
*/
protected function getActionKeyText($key)
{
switch ($key) {
case 'action':
return sprintf(
__('Transferring to Dropbox folder:<br/> <i>%1$s</i>', "duplicator-pro"),
$this->getStorageFolder()
);
case 'pending':
return sprintf(
__('Transfer to Dropbox folder %1$s is pending', "duplicator-pro"),
$this->getStorageFolder()
);
case 'failed':
return sprintf(
__('Failed to transfer to Dropbox folder %1$s', "duplicator-pro"),
$this->getStorageFolder()
);
case 'cancelled':
return sprintf(
__('Cancelled before could transfer to Dropbox folder %1$s', "duplicator-pro"),
$this->getStorageFolder()
);
case 'success':
return sprintf(
__('Transferred package to Dropbox folder %1$s', "duplicator-pro"),
$this->getStorageFolder()
);
default:
throw new Exception('Invalid key');
}
}
/**
* Render form config fields
*
* @param bool $echo Echo or return
*
* @return string
*/
public function renderConfigFields($echo = true)
{
return TplMng::getInstance()->render(
'dropboxaddon/configs/dropbox',
[
'storage' => $this,
'accountInfo' => $this->getAccountInfo(),
'quotaInfo' => $this->getQuota(),
'storageFolder' => $this->config['storage_folder'],
'maxPackages' => $this->config['max_packages'],
],
$echo
);
}
/**
* Update data from http request, this method don't save data, just update object properties
*
* @param string $message Message
*
* @return bool True if success and all data is valid, false otherwise
*/
public function updateFromHttpRequest(&$message = '')
{
if ((parent::updateFromHttpRequest($message) === false)) {
return false;
}
$this->config['max_packages'] = SnapUtil::sanitizeIntInput(SnapUtil::INPUT_REQUEST, 'dropbox_max_files', 10);
$this->config['storage_folder'] = self::getSanitizedInputFolder('_dropbox_storage_folder', 'remove');
$message = sprintf(
__('Dropbox Storage Updated. Folder: %1$s', 'duplicator-pro'),
$this->getStorageFolder()
);
return true;
}
/**
* Get the storage adapter
*
* @return DropboxAdapter
*/
public function getAdapter()
{
if (! $this->adapter) {
$global = DUP_PRO_Global_Entity::getInstance();
$this->adapter = new DropboxAdapter(
$this->setV2AccessTokenFromV1Client(),
$this->getStorageFolder(),
!$global->ssl_disableverify,
($global->ssl_useservercerts ? '' : DUPLICATOR_PRO_CERT_PATH),
$global->ipv4_only
);
}
return $this->adapter;
}
/**
* Get dropbox api key and secret
*
* @return array{app_key:string,app_secret:string}
*/
protected static function getApiKeySecret()
{
$dk = self::getDk1();
$dk = self::getDk2() . $dk;
$akey = CryptBlowfish::decrypt('EQNJ53++6/40fuF5ke+IaQ==', $dk);
$asec = CryptBlowfish::decrypt('ui25chqoBexPt6QDi9qmGg==', $dk);
$akey = trim($akey);
$asec = trim($asec);
if (($akey != $asec) || ($akey != "fdda100")) {
$akey = self::getAk1() . self::getAk2();
$asec = self::getAs1() . self::getAs2();
}
return [
'app_key' => $asec,
'app_secret' => $akey,
];
}
/**
* Get dk1
*
* @return string
*/
private static function getDk1()
{
return 'y8!!';
}
/**
* Get dk2
*
* @return string
*/
private static function getDk2()
{
return '32897';
}
/**
* Get ak1
*
* @return string
*/
private static function getAk1()
{
return strrev('i6gh72iv');
}
/**
* Get ak2
*
* @return string
*/
private static function getAk2()
{
return strrev('1xgkhw2');
}
/**
* Get as1
*
* @return string
*/
private static function getAs1()
{
return strrev('z7fl2twoo');
}
/**
* Get as2
*
* @return string
*/
private static function getAs2()
{
return strrev('2z2bfm');
}
/**
* Set v2 access token from v1 client
*
* @return string V2 access token
*/
protected function setV2AccessTokenFromV1Client()
{
if (strlen($this->config['v2_access_token']) > 0) {
return $this->config['v2_access_token'];
}
if (strlen($this->config['access_token']) == 0 || strlen($this->config['access_token_secret']) == 0) {
return '';
}
$oldToken = [
't' => $this->config['access_token'],
's' => $this->config['access_token_secret'],
];
$accessToken = DropboxClient::accessTokenFromOauth1($oldToken, self::getApiKeySecret());
if ($accessToken) {
$this->config['access_token'] = '';
$this->config['access_token_secret'] = '';
$this->config['v2_access_token'] = $accessToken;
$this->save();
} else {
DUP_PRO_Log::trace("Problem converting Dropbox access token");
$this->config['v2_access_token'] = '';
}
return $this->config['v2_access_token'];
}
/**
* Get account info
*
* @return false|array<string,mixed>
*/
protected function getAccountInfo()
{
if (!$this->isAuthorized()) {
return false;
}
try {
return $this->getAdapter()->getClient()->getAccountInfo();
} catch (Exception $e) {
DUP_PRO_Log::trace("Problem getting Dropbox account info. " . $e->getMessage());
}
return false;
}
/**
* Get dropbox quota
*
* @return false|array{used:int,total:int,perc:float,available:string}
*/
protected function getQuota()
{
if (!$this->isAuthorized()) {
return false;
}
$quota = $this->getAdapter()->getClient()->getQuota();
if (
!isset($quota['used']) ||
!isset($quota['allocation']['allocated']) ||
$quota['allocation']['allocated'] <= 0
) {
return false;
}
$quota_used = $quota['used'];
$quota_total = $quota['allocation']['allocated'];
$used_perc = round($quota_used * 100 / $quota_total, 1);
$available_quota = $quota_total - $quota_used;
return [
'used' => $quota_used,
'total' => $quota_total,
'perc' => $used_perc,
'available' => size_format($available_quota),
];
}
/**
* Get upload chunk size in bytes
*
* @return int bytes
*/
public function getUploadChunkSize()
{
$dGlobal = DynamicGlobalEntity::getInstance();
$size = (int) $dGlobal->getVal('dropbox_upload_chunksize_in_kb', 2000);
return $size * KB_IN_BYTES;
}
/**
* Get upload chunk timeout in seconds
*
* @return int timeout in microseconds, 0 unlimited
*/
public function getUploadChunkTimeout()
{
$global = DUP_PRO_Global_Entity::getInstance();
return (int) ($global->php_max_worker_time_in_sec <= 0 ? 0 : $global->php_max_worker_time_in_sec * SECONDS_IN_MICROSECONDS);
}
/**
* @return void
*/
public static function registerType()
{
parent::registerType();
add_action('duplicator_update_global_storage_settings', function () {
$dGlobal = DynamicGlobalEntity::getInstance();
foreach (static::getDefaultSettings() as $key => $default) {
$value = SnapUtil::sanitizeIntInput(SnapUtil::INPUT_REQUEST, $key, $default);
$dGlobal->setVal($key, $value);
}
});
}
/**
* Get default settings
*
* @return array<string, scalar>
*/
protected static function getDefaultSettings()
{
return [
'dropbox_upload_chunksize_in_kb' => 2000,
'dropbox_transfer_mode' => DUP_PRO_Dropbox_Transfer_Mode::Unconfigured,
];
}
/**
* @return void
*/
public static function renderGlobalOptions()
{
$values = static::getDefaultSettings();
$dGlobal = DynamicGlobalEntity::getInstance();
foreach ($values as $key => $default) {
$values[$key] = $dGlobal->getVal($key, $default);
}
?>
<h3 class="title"><?php echo esc_html(static::getStypeName()) ?> </h3>
<hr size="1" />
<table class="form-table">
<tr valign="top">
<th scope="row"><label><?php esc_html_e("Upload Chunk Size", 'duplicator-pro'); ?></label></th>
<td>
<input
class="dup-narrow-input text-right"
name="dropbox_upload_chunksize_in_kb"
id="dropbox_upload_chunksize_in_kb"
type="number"
min="100"
data-parsley-required
data-parsley-type="number"
data-parsley-errors-container="#dropbox_upload_chunksize_in_kb_error_container"
value="<?php echo (int) $values['dropbox_upload_chunksize_in_kb']; ?>"
>&nbsp;<b>KB</b>
<div id="dropbox_upload_chunksize_in_kb_error_container" class="duplicator-error-container"></div>
<p class="description">
<?php esc_html_e('How much should be uploaded to Dropbox per attempt. Higher=faster but less reliable.', 'duplicator-pro'); ?>
</p>
</td>
</tr>
</table>
<?php
}
}

72
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/dropboxaddon/src/Utils/Autoloader.php Normal file
View File

@@ -0,0 +1,72 @@
<?php
namespace Duplicator\Addons\DropboxAddon\Utils;
use Duplicator\Addons\DropboxAddon\DropboxAddon;
use Duplicator\Utils\AbstractAutoloader;
class Autoloader extends AbstractAutoloader
{
const ROOT_VENDOR = 'VendorDuplicator\\Dropbox\\';
const VENDOR_PATH = DropboxAddon::ADDON_PATH . '/vendor-prefixed/';
/**
* Register autoloader function
*
* @return void
*/
public static function register()
{
spl_autoload_register([__CLASS__, 'load']);
require_once DropboxAddon::ADDON_PATH . '/vendor-prefixed/guzzlehttp/guzzle/src/functions_include.php';
require_once DropboxAddon::ADDON_PATH . '/vendor-prefixed/guzzlehttp/promises/src/functions_include.php';
require_once DropboxAddon::ADDON_PATH . '/vendor-prefixed/guzzlehttp/psr7/src/functions_include.php';
require_once DropboxAddon::ADDON_PATH . '/vendor-prefixed/ralouphie/getallheaders/src/getallheaders.php';
}
/**
* Load class
*
* @param string $className class name
*
* @return void
*/
public static function load($className)
{
if (strpos($className, self::ROOT_VENDOR) === 0) {
foreach (self::getNamespacesVendorMapping() as $namespace => $mappedPath) {
if (strpos($className, $namespace) !== 0) {
continue;
}
$filepath = self::getFilenameFromClass($className, $namespace, $mappedPath);
if (file_exists($filepath)) {
include $filepath;
return;
}
}
}
}
/**
* Return namespace mapping
*
* @return string[]
*/
protected static function getNamespacesVendorMapping()
{
return [
self::ROOT_VENDOR . 'Google\\Service' => self::VENDOR_PATH . 'google/apiclient-services/src',
self::ROOT_VENDOR . 'Google\\Auth' => self::VENDOR_PATH . 'google/auth/src',
self::ROOT_VENDOR . 'Google' => self::VENDOR_PATH . 'google/apiclient/src',
self::ROOT_VENDOR . 'GuzzleHttp\\Promise' => self::VENDOR_PATH . 'guzzlehttp/promises/src',
self::ROOT_VENDOR . 'GuzzleHttp\\Psr7' => self::VENDOR_PATH . 'guzzlehttp/psr7/src',
self::ROOT_VENDOR . 'GuzzleHttp' => self::VENDOR_PATH . 'guzzlehttp/guzzle/src',
self::ROOT_VENDOR . 'Psr\\Http\\Message' => self::VENDOR_PATH . 'psr/http-message/src',
self::ROOT_VENDOR . 'Psr\\Log' => self::VENDOR_PATH . 'psr/log/Psr/Log',
self::ROOT_VENDOR . 'Psr\\Cache' => self::VENDOR_PATH . 'psr/cache/src',
self::ROOT_VENDOR . 'Spatie\\Dropbox' => self::VENDOR_PATH . 'spatie/dropbox-api/src',
];
}
}

179
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/dropboxaddon/src/Utils/DropboxClient.php Normal file
View File

@@ -0,0 +1,179 @@
<?php
namespace Duplicator\Addons\DropboxAddon\Utils;
use DUP_PRO_Global_Entity;
use DUP_PRO_Log;
use VendorDuplicator\Dropbox\GuzzleHttp\Client as GuzzleClient;
use VendorDuplicator\Dropbox\Spatie\Dropbox\Client;
class DropboxClient extends Client
{
const OAUTH2_URL = 'https://www.dropbox.com/oauth2/';
/**
* Class contructor
*
* @param string $accessToken The access token
* @param GuzzleClient|null $client The HTTP client
* @param int $maxChunkSize The maximum size of a chunk
* @param int $maxUploadChunkRetries The maximum number of times to retry a chunk upload
* @param bool $sslVerify If true, use SSL
* @param string $sslCert If empty use server cert
* @param bool $ipv4Only If true, use IPv4 only
*/
public function __construct(
$accessToken,
GuzzleClient $client = null,
$maxChunkSize = self::MAX_CHUNK_SIZE,
$maxUploadChunkRetries = 0,
$sslVerify = true,
$sslCert = '',
$ipv4Only = false
) {
if (!$client) {
$options = [];
if ($sslVerify === false) {
$verify = false;
} elseif (strlen($sslCert) === 0) {
$verify = true;
} else {
$verify = $sslCert;
}
$options['verify'] = $verify;
if ($ipv4Only) {
$options['force_ip_resolve'] = 'v4';
}
$options['handler'] = self::createHandler();
$client = new GuzzleClient($options);
}
parent::__construct($accessToken, $client, $maxChunkSize, $maxUploadChunkRetries);
}
/**
* Exchange the oauth1 token for an oauth2 token
*
* @see https://www.dropbox.com/developers/documentation/http/documentation#auth-token-from_oauth1
*
* @param array{t: string, s: string} $token The oauth1 token
* @param array{app_key: string, app_secret: string} $app_config The app config
*
* @return string|false
*/
public static function accessTokenFromOauth1($token, $app_config)
{
$url = "https://api.dropboxapi.com/2/auth/token/from_oauth1";
$response = wp_remote_post($url, [
'timeout' => 30,
'headers' => [
'Authorization' => 'Basic ' . base64_encode($app_config['app_key'] . ':' . $app_config['app_secret']),
],
'body' => [
'oauth1_token' => $token['t'],
'oauth1_token_secret' => $token['s'],
],
]);
if (is_wp_error($response)) {
DUP_PRO_Log::traceObject("[DropboxClient] Something wrong with while trying to get v2_access_token with oauth1 token.", $response);
return false;
}
$ret_obj = json_decode($response['body']);
if (isset($ret_obj->oauth2_token)) {
return $ret_obj->oauth2_token;
}
return false;
}
/**
* Use the app config to authenticate and get the access token
*
* @param string $auth_code The authorization code
* @param array{app_key: string, app_secret: string} $app_config The app config
*
* @return bool
*/
public function authenticate($auth_code, $app_config)
{
$url = self::OAUTH2_URL . 'token';
$args = $this->injectExtraReqArgs([
'timeout' => 30,
'body' => [
'client_id' => $app_config['app_key'],
'client_secret' => $app_config['app_secret'],
'code' => $auth_code,
'grant_type' => 'authorization_code',
],
]);
$response = wp_remote_post($url, $args);
if (is_wp_error($response)) {
DUP_PRO_Log::traceObject("Something wrong with while trying to get v2_access_token with code", $response);
return false;
}
DUP_PRO_Log::traceObject("Got v2 access_token", $response);
$ret_obj = json_decode($response['body']);
if (isset($ret_obj->access_token)) {
return $ret_obj->access_token;
}
return false;
}
/**
* Get the account's usage quota information.
*
* @return array{used: int, allocation: array{allocated: int}}|false
*/
public function getQuota()
{
try {
return $this->rpcEndpointRequest('users/get_space_usage');
} catch (\Exception $e) {
\DUP_PRO_Log::trace('[DropboxClient] ' . $e->getMessage());
return false;
}
}
/**
* Set the timeout for the client
*
* @param int $timeout The timeout in seconds
*
* @return void
*/
public function setTimeout($timeout)
{
if ($timeout > 0) {
$this->client = new GuzzleClient(['handler' => self::createHandler(), 'timeout' => $timeout]);
} else {
$this->client = new GuzzleClient(['handler' => self::createHandler()]);
}
}
/**
* Inject extra request arguments
*
* @param array<string, mixed> $opts The request options
*
* @return array<string, mixed>
*/
private function injectExtraReqArgs(array $opts)
{
$global = DUP_PRO_Global_Entity::getInstance();
$opts['sslverify'] = !$global->ssl_disableverify;
if (!$global->ssl_useservercerts) {
$opts['sslcertificates'] = DUPLICATOR_PRO_CERT_PATH;
}
return $opts;
}
}

285
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/dropboxaddon/template/dropboxaddon/configs/dropbox.php Normal file
View File

@@ -0,0 +1,285 @@
<?php
/**
* Duplicator messages sections
*
* @package Duplicator
* @copyright (c) 2022, Snap Creek LLC
*/
use Duplicator\Addons\DropboxAddon\Models\DropboxStorage;
defined("ABSPATH") or die("");
/**
* Variables
*
* @var \Duplicator\Core\Controllers\ControllersManager $ctrlMng
* @var \Duplicator\Core\Views\TplMng $tplMng
* @var array<string, mixed> $tplData
* @var DropboxStorage $storage
*/
$storage = $tplData["storage"];
/** @var false|object */
$accountInfo = $tplData["accountInfo"];
/** @var false|array{used:int,total:int,perc:float,available:string} */
$quotaInfo = $tplData["quotaInfo"];
/** @var string */
$storageFolder = $tplData["storageFolder"];
/** @var int */
$maxPackages = $tplData["maxPackages"];
$tplMng->render('admin_pages/storages/parts/provider_head');
?>
<tr>
<th scope="row"><label><?php esc_html_e("Authorization", 'duplicator-pro'); ?></label></th>
<td class="dropbox-authorize">
<div class="authorization-state" id="state-unauthorized">
<!-- CONNECT -->
<button id="dpro-dropbox-connect-btn" type="button" class="button button-large" onclick="DupPro.Storage.Dropbox.DropboxGetAuthUrl();">
<i class="fa fa-plug"></i> <?php esc_html_e('Connect to Dropbox', 'duplicator-pro'); ?>
<img
src="<?php echo esc_url(DUPLICATOR_PRO_IMG_URL . '/dropbox.svg'); ?>"
style='vertical-align: middle; margin:-2px 0 0 3px; height:18px; width:18px'
>
</button>
</div>
<div class="authorization-state" id="state-waiting-for-request-token">
<div style="padding:10px">
<i class="fas fa-circle-notch fa-spin"></i> <?php esc_html_e('Getting Dropbox request token...', 'duplicator-pro'); ?>
</div>
</div>
<div class="authorization-state" id="state-waiting-for-auth-button-click">
<!-- STEP 2 -->
<b><?php esc_html_e("Step 1:", 'duplicator-pro'); ?></b>&nbsp;
<?php esc_html_e(' Duplicator needs to authorize at the Dropbox.com website.', 'duplicator-pro'); ?>
<div class="auth-code-popup-note">
<?php
echo esc_html__(
'Note: Clicking the button below will open a new tab/window. Please be sure your browser does not block popups.',
'duplicator-pro'
) . ' ' .
esc_html__('If a new tab/window does not open check your browsers address bar to allow popups from this URL.', 'duplicator-pro');
?>
</div>
<button id="auth-redirect" type="button" class="button button-large" onclick="DupPro.Storage.Dropbox.OpenAuthPage(); return false;">
<i class="fa fa-user"></i> <?php esc_html_e('Authorize Dropbox', 'duplicator-pro'); ?>
</button>
<br/><br/>
<div id="dropbox-auth-code-area">
<b><?php esc_html_e('Step 2:', 'duplicator-pro'); ?></b>
<?php esc_html_e("Paste code from Dropbox authorization page.", 'duplicator-pro'); ?> <br/>
<input style="width:400px" id="dropbox-auth-code" name="dropbox-auth-code" />
</div>
<!-- STEP 3 -->
<b><?php esc_html_e("Step 3:", 'duplicator-pro'); ?></b>&nbsp;
<?php esc_html_e('Finalize Dropbox validation by clicking the "Finalize Setup" button.', 'duplicator-pro'); ?>
<br/>
<button id="dropbox-finalize-setup" type="button" class="button" >
<i class="fa fa-check-square"></i> <?php esc_html_e('Finalize Setup', 'duplicator-pro'); ?>
</button>
</div>
<div class="authorization-state" id="state-waiting-for-access-token">
<div>
<i class="fas fa-circle-notch fa-spin"></i>
<?php esc_html_e('Performing final authorization...Please wait', 'duplicator-pro'); ?>
</div>
</div>
<div class="authorization-state" id="state-authorized" style="margin-top:-5px">
<?php if ($storage->isAuthorized() && is_array($accountInfo)) : ?>
<h3>
<?php esc_html_e('Dropbox Account', 'duplicator-pro'); ?><br/>
<i class="dpro-edit-info">
<?php esc_html_e('Duplicator has been authorized to access this user\'s Dropbox account', 'duplicator-pro'); ?>
</i>
</h3>
<div id="dropbox-account-info">
<label><?php esc_html_e('Name', 'duplicator-pro'); ?>:</label>
<?php echo esc_html($accountInfo['name']['display_name']); ?><br/>
<label><?php esc_html_e('Email', 'duplicator-pro'); ?>:</label>
<?php echo esc_html($accountInfo['email']); ?>
<?php if ($quotaInfo) { ?>
<br/>
<label><?php esc_html_e('Quota Usage', 'duplicator-pro'); ?>:</label>
<?php
printf(esc_html__('%1$s%% used, %2$s available', 'duplicator-pro'), (int) $quotaInfo['perc'], $quotaInfo['available']);
}
?>
</div>
<?php endif; ?>
<br/>
<button type="button" class="button" onclick='DupPro.Storage.Dropbox.CancelAuthorization();'>
<?php esc_html_e('Cancel Authorization', 'duplicator-pro'); ?>
</button><br/>
<i class="dpro-edit-info">
<?php esc_html_e('Disassociates storage provider with the Dropbox account. Will require re-authorization.', 'duplicator-pro'); ?>
</i>
</div>
</td>
</tr>
<tr>
<th scope="row"><label for="_dropbox_storage_folder"><?php esc_html_e("Storage Folder", 'duplicator-pro'); ?></label></th>
<td>
<b>//Dropbox/Apps/Duplicator Pro/</b>
<input id="_dropbox_storage_folder" name="_dropbox_storage_folder"
type="text" value="<?php echo esc_attr($storageFolder); ?>" class="dpro-storeage-folder-path" />
<p>
<i>
<?php
esc_html_e(
"Folder where packages will be stored. This should be unique for each web-site using Duplicator.",
'duplicator-pro'
); ?>
</i>
</p>
</td>
</tr>
<tr>
<th scope="row"><label for=""><?php esc_html_e("Max Packages", 'duplicator-pro'); ?></label></th>
<td>
<label for="dropbox_max_files">
<input
id="dropbox_max_files"
name="dropbox_max_files"
type="number"
value="<?php echo (int) $maxPackages; ?>"
min="0"
maxlength="4"
data-parsley-errors-container="#dropbox_max_files_error_container"
data-parsley-required="true"
data-parsley-type="number"
data-parsley-min="0"
>
<?php esc_html_e("Number of packages to keep in folder.", 'duplicator-pro'); ?> <br/>
<i><?php esc_html_e("When this limit is exceeded, the oldest package will be deleted. Set to 0 for no limit.", 'duplicator-pro'); ?></i>
</label>
<div id="dropbox_max_files_error_container" class="duplicator-error-container"></div>
</td>
</tr>
<?php $tplMng->render('admin_pages/storages/parts/provider_foot'); ?>
<?php
$alertConnStatus = new DUP_PRO_UI_Dialog();
$alertConnStatus->title = __('Dropbox Connection Status', 'duplicator-pro');
$alertConnStatus->message = ''; // javascript inserted message
$alertConnStatus->initAlert();
?>
<script>
jQuery(document).ready(function ($) {
// DROPBOX RELATED METHODS
DupPro.Storage.Dropbox.AuthorizationStates = {
UNAUTHORIZED: 0,
WAITING_FOR_REQUEST_TOKEN: 1,
WAITING_FOR_AUTH_BUTTON_CLICK: 2,
WAITING_FOR_ACCESS_TOKEN: 3,
AUTHORIZED: 4
}
DupPro.Storage.Dropbox.authorizationState = <?php echo ($storage->isAuthorized() ? 4 : 0); ?>;
DupPro.Storage.Dropbox.CancelAuthorization = function () {
DupPro.Storage.RevokeAuth(<?php echo (int) $storage->getId(); ?>);
}
DupPro.Storage.Dropbox.DropboxGetAuthUrl = function ()
{
DupPro.Storage.Dropbox.AuthUrl = <?php echo json_encode($storage->getAuthorizationUrl()); ?>;
jQuery("#state-waiting-for-auth-button-click").show();
};
DupPro.Storage.Dropbox.TransitionAuthorizationState = function (newState)
{
jQuery('.authorization-state').hide();
jQuery('.dropbox_access_type').prop('disabled', true);
jQuery('.button_dropbox_test').prop('disabled', true);
switch (newState) {
case DupPro.Storage.Dropbox.AuthorizationStates.UNAUTHORIZED:
jQuery('.dropbox_access_type').prop('disabled', false);
$("#dropbox_authorization_state").val(DupPro.Storage.Dropbox.AuthorizationStates.UNAUTHORIZED);
DupPro.Storage.Dropbox.requestToken = null;
jQuery("#state-unauthorized").show();
break;
case DupPro.Storage.Dropbox.AuthorizationStates.WAITING_FOR_REQUEST_TOKEN:
DupPro.Storage.Dropbox.GetRequestToken();
jQuery("#state-waiting-for-request-token").show();
break;
case DupPro.Storage.Dropbox.AuthorizationStates.WAITING_FOR_AUTH_BUTTON_CLICK:
// Nothing to do here other than show the button and wait
jQuery("#state-waiting-for-auth-button-click").show();
break;
case DupPro.Storage.Dropbox.AuthorizationStates.WAITING_FOR_ACCESS_TOKEN:
jQuery("#state-waiting-for-access-token").show();
if (DupPro.Storage.Dropbox.requestToken != null) {
DupPro.Storage.Dropbox.GetAccessToken();
} else {
<?php $alertConnStatus->showAlert(); ?>
let alertMsg = "<i class='fas fa-exclamation-triangle'></i> " +
"<?php esc_html_e('Tried transitioning to auth button click but don\'t have the request token!', 'duplicator-pro'); ?>";
<?php $alertConnStatus->updateMessage("alertMsg"); ?>
DupPro.Storage.Dropbox.TransitionAuthorizationState(DupPro.Storage.Dropbox.AuthorizationStates.UNAUTHORIZED);
}
break;
case DupPro.Storage.Dropbox.AuthorizationStates.AUTHORIZED:
var token = $("#dropbox_access_token").val();
var token_secret = $("#dropbox_access_token_secret").val();
DupPro.Storage.Dropbox.accessToken = {};
DupPro.Storage.Dropbox.accessToken.t = token;
DupPro.Storage.Dropbox.accessToken.s = token_secret;
jQuery("#state-authorized").show();
jQuery('.button_dropbox_test').prop('disabled', false);
break;
}
DupPro.Storage.Dropbox.authorizationState = newState;
}
DupPro.Storage.Dropbox.OpenAuthPage = function ()
{
window.open(DupPro.Storage.Dropbox.AuthUrl, '_blank');
}
$('#dropbox-finalize-setup').click(function (event) {
event.stopPropagation();
if ($('#dropbox-auth-code').val().length > 5) {
DupPro.Storage.PrepareForSubmit();
//$("#dup-storage-form").submit();
DupPro.Storage.Authorize(
<?php echo (int) $storage->getId(); ?>,
<?php echo (int) $storage->getSType(); ?>,
{
'name': $('#name').val(),
'notes': $('#notes').val(),
'storage_folder': $('#_dropbox_storage_folder').val(),
'max_packages': $('#dropbox_max_files').val(),
'auth_code' : $('#dropbox-auth-code').val()
}
);
} else {
<?php $alertConnStatus->showAlert(); ?>
let alertMsg = "<i class='fas fa-exclamation-triangle'></i> " +
"<?php esc_html_e('Please enter your Dropbox authorization code!', 'duplicator-pro'); ?>";
<?php $alertConnStatus->updateMessage("alertMsg"); ?>
}
return false;
});
DupPro.Storage.Dropbox.TransitionAuthorizationState(DupPro.Storage.Dropbox.authorizationState);
$('button#auth-validate').prop('disabled', true);
});
</script>

130
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/ftpaddon/FtpAddon.php Normal file
View File

@@ -0,0 +1,130 @@
<?php
/**
* FTP/SFTP ADDON
*
* Name: Duplicator PRO base
* Version: 1
* Author: Duplicator
* Author URI: https://duplicator.com/
*
* PHP version 5.3
*
* @category Duplicator
* @package Plugin
* @author Duplicator
* @copyright 2011-2021 Snapcreek LLC
* @license https://www.gnu.org/licenses/gpl-3.0.html GPLv3
* @version GIT: $Id$
* @link https://duplicator.com/
*/
namespace Duplicator\Addons\FtpAddon;
use Duplicator\Addons\FtpAddon\Models\FTPStorage;
use Duplicator\Addons\FtpAddon\Models\SFTPStorage;
use Duplicator\Core\Addons\AbstractAddonCore;
use Duplicator\Models\Storages\AbstractStorageEntity;
/**
* Storage ftp/sftp addon class
*/
class FtpAddon extends AbstractAddonCore
{
const ADDON_PATH = __DIR__;
/**
* @return void
*/
public function init()
{
add_action('init', [$this, 'hookInit']);
add_action('duplicator_pro_register_storage_types', [$this, 'registerStorages']);
add_filter('duplicator_template_file', array(__CLASS__, 'getTemplateFile'), 10, 2);
add_filter('duplicator_usage_stats_storages_infos', array(__CLASS__, 'getStorageUsageStats'), 10);
}
/**
* Function calle on duplicator_addons_loaded hook
*
* @return void
*/
public function hookInit()
{
}
/**
* Register storages
*
* @return void
*/
public function registerStorages()
{
FTPStorage::registerType();
SFTPStorage::registerType();
}
/**
* Return template file path
*
* @param string $path path to the template file
* @param string $slugTpl slug of the template
*
* @return string
*/
public static function getTemplateFile($path, $slugTpl)
{
if (strpos($slugTpl, 'ftpaddon/') === 0) {
return self::getAddonPath() . '/template/' . $slugTpl . '.php';
}
return $path;
}
/**
* Get storage usage stats
*
* @param array<string,int> $storageNums Storages num
*
* @return array<string,int>
*/
public static function getStorageUsageStats($storageNums)
{
if (($storages = AbstractStorageEntity::getAll()) === false) {
$storages = [];
}
$storageNums['storages_ftp_count'] = 0;
$storageNums['storages_sftp_count'] = 0;
foreach ($storages as $index => $storage) {
switch ($storage->getSType()) {
case FTPStorage::getSType():
$storageNums['storages_ftp_count']++;
break;
case SFTPStorage::getSType():
$storageNums['storages_sftp_count']++;
break;
}
}
return $storageNums;
}
/**
*
* @return string
*/
public static function getAddonPath()
{
return __DIR__;
}
/**
*
* @return string
*/
public static function getAddonFile()
{
return __FILE__;
}
}

958
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/ftpaddon/src/Models/FTPCurlStorageAdapter.php Normal file
View File

@@ -0,0 +1,958 @@
<?php
namespace Duplicator\Addons\FtpAddon\Models;
use CurlHandle;
use Duplicator\Addons\FtpAddon\Utils\FTPUtils;
use Duplicator\Models\Storages\AbstractStorageAdapter;
use Duplicator\Models\Storages\StoragePathInfo;
use Duplicator\Libs\Snap\SnapIO;
use Exception;
class FTPCurlStorageAdapter extends AbstractStorageAdapter
{
/** @var int */
const DEFAULT_CHUNK_SIZE = 2 * 1024 * 1024;
/** @var string */
private $root = '';
/** @var string */
private $server = '';
/** @var int */
private $port = 21;
/** @var string */
private $username = '';
/** @var string */
private $password = '';
/** @var int */
private $timeoutInSec = 15;
/** @var bool */
private $ssl = false;
/** @var bool */
private $passiveMode = false;
/** @var resource */
private $sourceFileHandle = null;
/** @var string */
private $lastSourceFilePath = '';
/** @var resource */
private $destFileHandle = null;
/** @var string */
private $lastDestFilePath = '';
/** @var resource */
private $tempFileHandle = null;
/** @var string */
private $lastTempFilePath = '';
/** @var null|resource|CurlHandle */
private $connection = null;
/** @var int */
private $throttle = 0;
/**
* Class constructor
*
* @param string $server The server to connect to
* @param int $port The port to connect to
* @param string $username The username to use
* @param string $password The password to use
* @param string $root The root directory to use
* @param int $timeoutInSec The timeout in seconds
* @param bool $ssl Whether to use SSL
* @param bool $passiveMode Whether to use passive mode
* @param int $throttle The throttle in microseconds
*/
public function __construct(
$server,
$port = 21,
$username = '',
$password = '',
$root = '/',
$timeoutInSec = 15,
$ssl = false,
$passiveMode = false,
$throttle = 0
) {
$this->server = $server;
$this->port = (int) $port;
$this->username = $username;
$this->password = $password;
$this->root = SnapIO::trailingslashit($root);
$this->timeoutInSec = max(1, (int) $timeoutInSec);
$this->ssl = (bool) $ssl;
$this->passiveMode = (bool) $passiveMode;
$this->throttle = max(0, (int) $throttle);
}
/**
* Opens the FTP connection and initializes root directory
*
* @param string $errorMsg The error message to return
*
* @return bool True on success, false on failure
*/
public function initialize(&$errorMsg = '')
{
if (!$this->isDir('/') && !$this->createDir('/')) {
$errorMsg = "Couldn't create root directory.";
return false;
}
$this->wait();
return true;
}
/**
* Throttle the connection
*
* @return void
*/
protected function wait()
{
if ($this->throttle > 0) {
usleep($this->throttle);
}
}
/**
* Check if storage is valid and ready to use.
*
* @param string $errorMsg The error message if storage is invalid.
*
* @return bool
*/
public function isValid(&$errorMsg = '')
{
if (!$this->isConnectionInfoValid($errorMsg)) {
$errorMsg = "FTP connection info is invalid: " . $errorMsg;
return false;
}
if ($this->testConnection($errorMsg) === false) {
$errorMsg = "FTP connection failed: " . $errorMsg;
return false;
}
if (!$this->isDir('/')) {
$errorMsg = "FTP root directory doesn't exist.";
return false;
}
return true;
}
/**
* Checks if the connection info is valid
*
* @param string $errorMsg The error message to return
*
* @return bool
*/
protected function isConnectionInfoValid(&$errorMsg = '')
{
if (strlen($this->server) < 1) {
$errorMsg = "FTP server is empty.";
return false;
}
if (strlen($this->username) < 1) {
$errorMsg = "FTP username is empty.";
return false;
}
if (strlen($this->password) < 1) {
$errorMsg = "FTP password is empty.";
return false;
}
if ($this->port < 1) {
$errorMsg = "FTP port is invalid.";
return false;
}
if (strlen($this->root) < 1) {
$errorMsg = "FTP root directory is empty.";
return false;
}
return true;
}
/**
* test ftp connection
*
* @param string $errorMsg error message
*
* @return boolean
*/
private function testConnection(&$errorMsg = '')
{
$path = $this->getFullPath('/', true);
return $this->curlCall($path, [CURLOPT_TIMEOUT => $this->timeoutInSec]) !== false;
}
/**
* Create the directory specified by pathname, recursively if necessary.
*
* @param string $path The directory path.
*
* @return bool true on success or false on failure.
*/
protected function realCreateDir($path)
{
try {
$path = SnapIO::trailingslashit($this->getFullPath($path, true));
return $this->curlCall($path, [CURLOPT_FTP_CREATE_MISSING_DIRS => true]) !== false;
} finally {
$this->wait();
}
}
/**
* Create file with content.
*
* @param string $path The path to file.
* @param string $content The content of file.
*
* @return false|int The number of bytes that were written to the file, or false on failure.
*/
protected function realCreateFile($path, $content)
{
try {
if (($fullPath = $this->getFullPath($path)) === false) {
return false;
}
if ($this->exists($path) && !$this->delete($path)) {
return false;
}
$tmpFile = tempnam(sys_get_temp_dir(), 'duplicator-pro-');
if (($bytesWritten = file_put_contents($tmpFile, $content)) === false) {
return false;
}
if (($stream = @fopen($tmpFile, 'r')) === false) {
return false;
}
$success = $this->curlCall(
$fullPath,
[
CURLOPT_UPLOAD => true,
CURLOPT_NOPROGRESS => true,
CURLOPT_FTP_CREATE_MISSING_DIRS => true,
CURLOPT_INFILE => $stream,
CURLOPT_INFILESIZE => $bytesWritten,
]
);
@fclose($stream);
if ($success === false) {
return false;
}
return $bytesWritten;
} finally {
$this->wait();
}
}
/**
* Get file content.
*
* @param string $path The path to file.
*
* @return string|false The content of file or false on failure.
*/
public function getFileContent($path)
{
if (($path = $this->getFullPath($path)) === false) {
return false;
}
if (($content = $this->curlCall($path)) === false) {
return false;
}
return $content;
}
/**
* Move and/or rename a file or directory.
*
* @param string $oldPath Relative storage path
* @param string $newPath Relative storage path
*
* @return bool true on success or false on failure.
*/
protected function realMove($oldPath, $newPath)
{
try {
if (($fullOldPath = $this->getFullPath($oldPath)) === false) {
return false;
}
if (($fullNewPath = $this->getFullPath($newPath)) === false) {
return false;
}
return $this->curlCall('/', [CURLOPT_QUOTE => ["RNFR " . $fullOldPath, "RNTO " . $fullNewPath]]) !== false;
} finally {
$this->wait();
}
}
/**
* Delete reletative path from storage root.
*
* @param string $path The path to delete. (Accepts directories and files)
* @param bool $recursive Allows the deletion of nested directories specified in the pathname. Default to false.
*
* @return bool true on success or false on failure.
*/
protected function realDelete($path, $recursive = false)
{
try {
$fullPath = $this->getFullPath($path, true);
if ($this->isDir($path)) {
$fullPath = SnapIO::trailingslashit($fullPath);
if ($recursive) {
foreach ($this->scanDir($path) as $item) {
if (!$this->realDelete(SnapIO::trailingslashit($path) . $item, true)) {
return false;
}
}
}
return $this->curlCall('/', [CURLOPT_QUOTE => ["RMD " . $fullPath]]) !== false;
} elseif ($this->isFile($path)) {
return $this->curlCall('/', [CURLOPT_QUOTE => ["DELE " . $fullPath]]) !== false;
} else {
//path doesn't exist
return true;
}
} finally {
$this->wait();
}
}
/**
* Copy local file to storage, partial copy is supported.
* If destination file exists, it will be overwritten.
* If offset is less than the destination file size, the file will be truncated.
*
* @param string $sourceFile The source file full path
* @param string $storageFile Storage destination path
* @param int<0,max> $offset The offset where the data starts.
* @param int $length The maximum number of bytes read. Default to -1 (read all the remaining buffer).
* @param int $timeout The timeout for the copy operation in microseconds. Default to 0 (no timeout).
* @param array<string,mixed> $extraData Extra data to pass to copy function and updated during copy.
* Used for storages that need to maintain persistent data during copy intra-session.
*
* @return false|int The number of bytes that were written to the file, or false on failure.
*/
protected function realCopyToStorage($sourceFile, $storageFile, $offset = 0, $length = -1, $timeout = 0, &$extraData = [])
{
try {
$startTime = microtime(true);
if (($storageFileFullPath = $this->getFullPath($storageFile)) === false) {
return false;
}
if (!is_file($sourceFile)) {
return false;
}
if ($offset === 0 && $this->isFile($storageFile) && !$this->delete($storageFile)) {
return false;
}
// Uplaod file at once without any other operation
if (($timeout === 0 && $offset === 0 && $length < 0) || filesize($sourceFile) < $length) {
if (($content = @file_get_contents($sourceFile)) === false) {
return false;
}
return $this->createFile($storageFile, $content);
}
if (
($sourceFileHandle = $this->getSourceFileHandle($sourceFile)) === false ||
($tempFileHandle = $this->getTempFileHandle()) === false
) {
return false;
}
$bytesWritten = 0;
$length = $length < 0 ? self::DEFAULT_CHUNK_SIZE : $length;
do {
if (
@fseek($sourceFileHandle, $offset) === -1 ||
($chunk = @fread($sourceFileHandle, $length)) === false
) {
return false;
}
if (
@ftruncate($tempFileHandle, 0) === false ||
@rewind($tempFileHandle) === false ||
@fwrite($tempFileHandle, $chunk) === false
) {
return false;
}
@rewind($tempFileHandle);
$result = $this->curlCall(
$storageFileFullPath,
[
CURLOPT_FTPAPPEND => true,
CURLOPT_UPLOAD => true,
CURLOPT_FTP_CREATE_MISSING_DIRS => true,
CURLOPT_INFILE => $tempFileHandle,
CURLOPT_INFILESIZE => strlen($chunk),
]
);
if ($result === false) {
return false;
}
//abort on first chunk if no timeout
if ($timeout === 0) {
return $length;
}
$bytesWritten += strlen($chunk);
$offset += strlen($chunk);
} while ($timeout !== 0 && self::getElapsedTime($startTime) < $timeout && !feof($sourceFileHandle));
return $bytesWritten;
} finally {
$this->wait();
}
}
/**
* Copy storage file to local file, partial copy is supported.
* If destination file exists, it will be overwritten.
* If offset is less than the destination file size, the file will be truncated.
*
* @param string $storageFile The storage file path
* @param string $destFile The destination local file full path
* @param int<0,max> $offset The offset where the data starts.
* @param int $length The maximum number of bytes read. Default to -1 (read all the remaining buffer).
* @param int $timeout The timeout for the copy operation in microseconds. Default to 0 (no timeout).
* @param array<string,mixed> $extraData Extra data to pass to copy function and updated during copy.
* Used for storages that need to maintain persistent data during copy intra-session.
*
* @return false|int The number of bytes that were written to the file, or false on failure.
*/
public function copyFromStorage($storageFile, $destFile, $offset = 0, $length = -1, $timeout = 0, &$extraData = [])
{
try {
$startTime = microtime(true);
if (($fullPath = $this->getFullPath($storageFile)) === false) {
return false;
}
if (wp_mkdir_p(dirname($destFile)) == false) {
return false;
}
if ($offset === 0 && @file_exists($destFile) && !@unlink($destFile)) {
return false;
}
if (!$this->isFile($storageFile)) {
return false;
}
if ($timeout === 0 && $offset === 0 && $length < 0) {
if (($content = $this->getFileContent($storageFile)) === false) {
return false;
}
return @file_put_contents($destFile, $content);
}
if (($handle = $this->getDestFileHandle($destFile)) === false) {
return false;
}
if (@fseek($handle, $offset) === -1) {
return false;
}
$bytesWritten = 0;
$length = $length < 0 ? self::DEFAULT_CHUNK_SIZE : $length;
do {
if (@fseek($handle, $offset) === -1) {
return false;
}
$content = $this->curlCall(
$fullPath,
[
CURLOPT_RANGE => sprintf('%d-%d', $offset, $offset + $length - 1),
]
);
if (
$content === false ||
(strlen($content) > 0 && @fwrite($handle, $content) === false)
) {
return false;
}
if ($timeout === 0) {
return $length;
}
$bytesWritten += strlen($content);
$offset += strlen($content);
} while ($timeout !== 0 && self::getElapsedTime($startTime) < $timeout && strlen($content) > 0);
return $bytesWritten;
} finally {
$this->wait();
}
}
/**
* Get all files meta information in a folder
*
* @param string $path remote dir path
* @param bool $filterDots filters . and .. from the list
*
* @return array{array{name: string, size: int, modified: int, created: int, isDir: bool}}|array{}
*/
private function getRawListInfo($path, $filterDots = true)
{
//direactories need the trailing slash to be recognized as such
$path = SnapIO::trailingslashit($this->getFullPath($path, true));
$res = $this->curlCall($path, [CURLOPT_CUSTOMREQUEST => 'LIST']);
if ($res === false) {
return [];
}
$items = explode("\n", $res);
$items = array_filter($items, function ($item) {
return !empty($item);
});
if (empty($items)) {
return [];
}
if (strpos($items[0], 'total') !== false) {
array_shift($items);
}
$result = [];
foreach ($items as $key => $item) {
if (($parsed = FTPUtils::parseRawListString($item, $this->getSystemType())) !== false) {
if ($filterDots && ($parsed['name'] === '.' || $parsed['name'] === '..')) {
continue;
}
$result[] = $parsed;
}
}
return $result;
}
/**
* Get System type
*
* @return string
*/
private function getSystemType()
{
if (($res = $this->curlCall('/', [CURLOPT_CUSTOMREQUEST => 'SYST'])) === false) {
return 'UNIX';
}
$res = strtoupper($res);
if (strpos($res, 'WINDOWS') !== false) {
return 'WINDOWS_NT';
}
return 'UNIX';
}
/**
* Get path info.
*
* @param string $path Relative storage path, if empty, return root path info.
*
* @return StoragePathInfo|false The path info or false if path is invalid.
*/
public function getRealPathInfo($path)
{
if (($fullPath = $this->getFullPath($path, true)) === false) {
return false;
}
$matches = [];
$info = new StoragePathInfo();
$info->path = $path;
if (
($response = $this->curlCall($fullPath, [CURLOPT_HEADER => true, CURLOPT_NOBODY => true])) !== false &&
preg_match('/^Content-Length:\s*(\d+)/im', $response, $matches) === 1
) {
// Is file
$info->exists = true;
$info->isDir = false;
$info->size = (int) $matches[1];
$response = $this->curlCall($fullPath, [CURLOPT_CUSTOMREQUEST => 'MDTM']);
$matches = [];
if (preg_match('/^(\d{14})/', $response, $matches) === 1) {
$info->modified = strtotime($matches[1]);
} else {
$info->modified = time();
}
$info->created = $info->modified;
} elseif ($this->curlCall(trailingslashit($fullPath), [CURLOPT_CUSTOMREQUEST => 'NLST']) !== false) {
// Is folder
$info = new StoragePathInfo();
$info->path = $path;
$info->exists = true;
$info->isDir = true;
$info->size = 0;
$info->created = time();
$info->modified = time();
} else {
// Not exists
$info->exists = false;
$info->isDir = false;
}
return $info;
}
/**
* Get the list of files and directories inside the specified path.
*
* @param string $path Relative storage path, if empty, scan root path.
* @param bool $files If true, add files to the list. Default to true.
* @param bool $folders If true, add folders to the list. Default to true.
*
* @return string[] The list of files and directories, empty array if path is invalid.
*/
public function scanDir($path, $files = true, $folders = true)
{
$infoList = $this->getRawListInfo($path);
$result = [];
foreach ($infoList as $item) {
if ($item['isDir'] && !$folders) {
continue;
}
if (!$item['isDir'] && !$files) {
continue;
}
$result[] = $item['name'];
}
return $result;
}
/**
* Check if directory is empty.
*
* @param string $path The folder path
* @param string[] $filters Filters to exclude files and folders from the check, if start and end with /, use regex.
*
* @return bool True is ok, false otherwise
*/
public function isDirEmpty($path, $filters = [])
{
if (!$this->isDir($path)) {
return false;
}
$regexFilters = [];
$normalFilters = [];
foreach ($filters as $filter) {
if (preg_match('/^\/.*\/$/', $filter) === 1) {
$regexFilters[] = $filter;
} else {
$normalFilters[] = $filter;
}
}
$contents = $this->scanDir($path);
foreach ($contents as $item) {
if (in_array($item, $normalFilters)) {
continue;
}
foreach ($regexFilters as $regexFilter) {
if (preg_match($regexFilter, $item) === 1) {
continue 2;
}
}
return false;
}
return true;
}
/**
* Destroy the storage on deletion.
*
* @return bool true on success or false on failure.
*/
public function destroy()
{
// Don't delete if root directory
if (
preg_match('/^[a-zA-Z]:\/$/', $this->root) === 1 ||
preg_match('/^\/$/', $this->root) === 1
) {
return true;
}
return $this->delete('/', true);
}
/**
* Destruct
*
* @return void
*/
public function __destruct()
{
if (is_resource($this->sourceFileHandle)) {
fclose($this->sourceFileHandle);
}
if (is_resource($this->tempFileHandle)) {
fclose($this->tempFileHandle);
}
if (is_resource($this->destFileHandle)) {
fclose($this->destFileHandle);
}
if ($this->connection !== null) {
curl_close($this->connection);
}
}
/**
* Do a curl call
*
* @param string $path where the curl call occur
* @param array<int,mixed> $options configuration options
* @param string $errorMsg error message
*
* @return string|false response or false on failure
*/
private function curlCall($path = '/', $options = [], &$errorMsg = '')
{
if ($this->connection === null) {
$this->connection = curl_init();
} else {
curl_reset($this->connection);
}
if ($this->connection === false) {
return false;
}
$path = ltrim($path, '/\\');
$options[CURLOPT_URL] = sprintf('ftp://%s:%d/%s', $this->server, $this->port, $path);
$options = array_replace($this->getDefaultOptions(), $options);
curl_setopt_array($this->connection, $options);
if (($response = curl_exec($this->connection)) === false) {
if (($errno = curl_errno($this->connection))) {
switch ($errno) {
case 6:
case 7:
$errorMsg = 'Unable to connect to FTP server. Please check your FTP hostname, port, and active mode settings. Error code: ' . $errno;
break;
case 8:
$errorMsg = 'Got an unexpected reply from FTP server. Error code: ' . $errno;
break;
case 9:
$errorMsg = 'Unable to change FTP directory. Please ensure that you have permission on the server. Error code: ' . $errno;
break;
case 23:
$errorMsg = 'Unable to download file from FTP server. Please ensure that you have enough disk space. Error code: ' . $errno;
break;
case 28:
$errorMsg = 'Connecting to FTP server timed out. Please check FTP hostname, port, username, password, and active mode ' .
'settings. Error code: ' . $errno;
break;
case 67:
$errorMsg = 'Unable to login to FTP server. Please check your username and password. Error code: ' . $errno;
break;
default:
$errorMsg = 'Unable to connect to FTP. Error code: ' . $errno . '. Error message: ' . curl_error($this->connection);
break;
}
}
return false;
}
$http_code = curl_getinfo($this->connection, CURLINFO_HTTP_CODE);
if ($http_code >= 400) {
$errorMsg = sprintf('Error code: %s.', $http_code);
return false;
}
return $response;
}
/**
* Returns default options for cURL
*
* @return array<int,mixed>
*/
private function getDefaultOptions()
{
$options = [
CURLOPT_USERPWD => sprintf('%s:%s', $this->username, $this->password),
CURLOPT_HEADER => false,
CURLOPT_RETURNTRANSFER => true,
CURLOPT_BINARYTRANSFER => true,
CURLOPT_CONNECTTIMEOUT => $this->timeoutInSec,
CURLOPT_TIMEOUT => $this->timeoutInSec,
];
if ($this->ssl) {
$options[CURLOPT_SSL_VERIFYPEER] = false;
$options[CURLOPT_SSL_VERIFYHOST] = false;
$options[CURLOPT_FTP_SSL] = CURLFTPSSL_TRY;
$options[CURLOPT_FTPSSLAUTH] = CURLFTPAUTH_TLS;
}
if ($this->passiveMode) {
$options[CURLOPT_FTP_USE_EPSV] = true;
} else {
$options[CURLOPT_FTP_USE_EPRT] = true;
$options[CURLOPT_FTPPORT] = 0;
}
return $options;
}
/**
* Returns the source file handle
*
* @param string $destFilePath The source file path
*
* @return resource|false returns the file handle or false on failure
*/
private function getDestFileHandle($destFilePath)
{
if ($this->lastDestFilePath === $destFilePath) {
return $this->destFileHandle;
}
if (is_resource($this->destFileHandle)) {
fclose($this->destFileHandle);
}
if (($this->destFileHandle = SnapIO::fopen($destFilePath, 'cb')) === false) {
return false;
}
$this->lastDestFilePath = $destFilePath;
return $this->destFileHandle;
}
/**
* Returns the source file handle
*
* @param string $sourceFilePath The source file path
*
* @return resource|false returns the file handle or false on failure
*/
private function getSourceFileHandle($sourceFilePath)
{
if ($this->lastSourceFilePath === $sourceFilePath) {
return $this->sourceFileHandle;
}
if (is_resource($this->sourceFileHandle)) {
fclose($this->sourceFileHandle);
}
if (($this->sourceFileHandle = SnapIO::fopen($sourceFilePath, 'r')) === false) {
return false;
}
$this->lastSourceFilePath = $sourceFilePath;
return $this->sourceFileHandle;
}
/**
* Returns an empty file stream to temporarlly store chunk data.
*
* @return resource|false
*/
private function getTempFileHandle()
{
if (is_resource($this->tempFileHandle)) {
if (ftruncate($this->tempFileHandle, 0) === false) {
return false;
}
if (rewind($this->tempFileHandle) === false) {
return false;
}
return $this->tempFileHandle;
}
if (@file_exists($this->lastTempFilePath)) {
@unlink($this->lastTempFilePath);
}
$this->lastTempFilePath = tempnam(sys_get_temp_dir(), 'duplicator_ftp_curl_tmpfile_');
if (($this->tempFileHandle = @fopen($this->lastTempFilePath, 'r+')) === false) {
return false;
}
return $this->tempFileHandle;
}
/**
* Return the full path of storage from relative path.
*
* @param string $path The relative storage path
* @param bool $acceptEmpty If true, return root path if path is empty. Default to false.
*
* @return string|false The full path or false if path is invalid.
*/
protected function getFullPath($path, $acceptEmpty = false)
{
$path = ltrim((string) $path, '/\\');
if (strlen($path) === 0) {
return $acceptEmpty ? SnapIO::trailingslashit($this->root) : false;
}
return $this->root . $path;
}
/**
* Elapsed time in microseconds
*
* @param float $startTime start time in microseconds
*
* @return float
*/
private static function getElapsedTime($startTime)
{
return (microtime(true) - $startTime) * SECONDS_IN_MICROSECONDS;
}
}

485
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/ftpaddon/src/Models/FTPStorage.php Normal file
View File

@@ -0,0 +1,485 @@
<?php
/**
*
* @package Duplicator
* @copyright (c) 2022, Snap Creek LLC
*/
namespace Duplicator\Addons\FtpAddon\Models;
use Duplicator\Core\Views\TplMng;
use Duplicator\Libs\Snap\SnapUtil;
use Duplicator\Models\DynamicGlobalEntity;
use Duplicator\Models\Storages\AbstractStorageEntity;
use Duplicator\Models\Storages\AbstractStorageAdapter;
use Exception;
class FTPStorage extends AbstractStorageEntity
{
const MIN_UPLOAD_CHUNK_SIZE_IN_MB = 1;
const DEFAULT_UPLOAD_CHUNK_SIZE_IN_MB = 5;
const MAX_UPLOAD_CHUNK_SIZE_IN_MB = 100;
/**
* Get default config
*
* @return array<string,scalar>
*/
protected static function getDefaultConfig()
{
$config = parent::getDefaultConfig();
$config = array_merge(
$config,
[
'server' => '',
'port' => 21,
'username' => '',
'password' => '',
'use_curl' => false,
'timeout_in_secs' => 15,
'ssl' => false,
'passive_mode' => true,
]
);
return $config;
}
/**
* Get stoage adapter
*
* @return AbstractStorageAdapter
*/
protected function getAdapter()
{
if ($this->adapter !== null) {
return $this->adapter;
}
if ($this->config['use_curl']) {
$this->adapter = new FTPCurlStorageAdapter(
$this->config['server'],
$this->config['port'],
$this->config['username'],
$this->config['password'],
$this->config['storage_folder'],
$this->config['timeout_in_secs'],
$this->config['ssl'],
$this->config['passive_mode']
);
} else {
$this->adapter = new FTPStorageAdapter(
$this->config['server'],
$this->config['port'],
$this->config['username'],
$this->config['password'],
$this->config['storage_folder'],
$this->config['timeout_in_secs'],
$this->config['ssl'],
$this->config['passive_mode']
);
}
return $this->adapter;
}
/**
* Will be called, automatically, when Serialize
*
* @return array<string, mixed>
*/
public function __serialize() // phpcs:ignore PHPCompatibility.FunctionNameRestrictions.NewMagicMethods.__serializeFound
{
$data = parent::__serialize();
unset($data['client']);
return $data;
}
/**
* Serialize
*
* Wakeup method.
*
* @return void
*/
public function __wakeup()
{
parent::__wakeup();
if ($this->legacyEntity) {
// Old storage entity
$this->legacyEntity = false;
// Make sure the storage type is right from the old entity
$this->storage_type = $this->getSType();
$this->config = [
'server' => $this->ftp_server,
'port' => $this->ftp_port,
'username' => $this->ftp_username,
'password' => $this->ftp_password,
'use_curl' => $this->ftp_use_curl,
'storage_folder' => '/' . ltrim($this->ftp_storage_folder, '/\\'),
'max_packages' => $this->ftp_max_files,
'timeout_in_secs' => $this->ftp_timeout_in_secs,
'ssl' => $this->ftp_ssl,
'passive_mode' => $this->ftp_passive_mode,
];
// reset old values
$this->ftp_server = '';
$this->ftp_port = 21;
$this->ftp_username = '';
$this->ftp_password = '';
$this->ftp_use_curl = false;
$this->ftp_storage_folder = '';
$this->ftp_max_files = 10;
$this->ftp_timeout_in_secs = 15;
$this->ftp_ssl = false;
$this->ftp_passive_mode = false;
}
// For legacy entities, we need to make sure the config is up to date
$this->config['port'] = (int) $this->config['port'];
$this->config['max_packages'] = (int) $this->config['max_packages'];
$this->config['timeout_in_secs'] = (int) $this->config['timeout_in_secs'];
}
/**
* Return the storage type
*
* @return int
*/
public static function getSType()
{
return 2;
}
/**
* Returns the FontAwesome storage type icon.
*
* @return string Returns the font-awesome icon
*/
public static function getStypeIcon()
{
return '<i class="fas fa-network-wired fa-fw"></i>';
}
/**
* Returns the storage type name.
*
* @return string
*/
public static function getStypeName()
{
return __('FTP', 'duplicator-pro');
}
/**
* Get priority, used to sort storages.
* 100 is neutral value, 0 is the highest priority
*
* @return int
*/
public static function getPriority()
{
return 80;
}
/**
* Get storage location string
*
* @return string
*/
public function getLocationString()
{
return "ftp://" . $this->config['server'] . ":" . $this->config['port'] . $this->getStorageFolder();
}
/**
* Check if storage is supported
*
* @return bool
*/
public static function isSupported()
{
return apply_filters('duplicator_pro_ftp_connect_exists', function_exists('ftp_connect'));
}
/**
* Get supported notice, displayed if storage isn't supported
*
* @return string html string or empty if storage is supported
*/
public static function getNotSupportedNotice()
{
if (static::isSupported()) {
return '';
}
return sprintf(
esc_html__(
'FTP Storage requires FTP module enabled. Please install the FTP module as described in the %s.',
'duplicator-pro'
),
'<a href="https://secure.php.net/manual/en/ftp.installation.php" target="_blank">https://secure.php.net/manual/en/ftp.installation.php</a>'
);
}
/**
* Check if storage is valid
*
* @return bool Return true if storage is valid and ready to use, false otherwise
*/
public function isValid()
{
return $this->getAdapter()->isValid();
}
/**
* Get upload chunk size in bytes
*
* @return int bytes
*/
public function getUploadChunkSize()
{
$dGlobal = DynamicGlobalEntity::getInstance();
return $dGlobal->getVal('ftp_upload_chunksize_in_mb', self::DEFAULT_UPLOAD_CHUNK_SIZE_IN_MB) * 1024 * 1024;
}
/**
* Get upload chunk timeout in seconds
*
* @return int timeout in microseconds, 0 unlimited
*/
public function getUploadChunkTimeout()
{
return (int) ($this->config['timeout_in_secs'] <= 0 ? 0 : $this->config['timeout_in_secs'] * SECONDS_IN_MICROSECONDS);
}
/**
* Get action key text
*
* @param string $key Key name (action, pending, failed, cancelled, success)
*
* @return string
*/
protected function getActionKeyText($key)
{
switch ($key) {
case 'action':
return sprintf(
__('Transferring to FTP server %1$s in folder:<br/> <i>%2$s</i>', "duplicator-pro"),
$this->config['server'],
$this->getStorageFolder()
);
case 'pending':
return sprintf(
__('Transfer to FTP server %1$s in folder %2$s is pending', "duplicator-pro"),
$this->config['server'],
$this->getStorageFolder()
);
case 'failed':
return sprintf(
__('Failed to transfer to FTP server %1$s in folder %2$s', "duplicator-pro"),
$this->config['server'],
$this->getStorageFolder()
);
case 'cancelled':
return sprintf(
__('Cancelled before could transfer to FTP server:<br/>%1$s in folder %2$s', "duplicator-pro"),
$this->config['server'],
$this->getStorageFolder()
);
case 'success':
return sprintf(
__('Transferred package to FTP server:<br/>%1$s in folder %2$s', "duplicator-pro"),
$this->config['server'],
$this->getStorageFolder()
);
default:
throw new Exception('Invalid key');
}
}
/**
* List quick view
*
* @param bool $echo Echo or return
*
* @return string
*/
public function getListQuickView($echo = true)
{
ob_start();
?>
<div>
<label><?php esc_html_e('Server', 'duplicator-pro'); ?>:</label>
<?php echo esc_html($this->config['server']); ?>: <?php echo intval($this->config['port']); ?> <br/>
<label><?php esc_html_e('Location', 'duplicator-pro') ?>:</label>
<?php
echo wp_kses(
$this->getHtmlLocationLink(),
[
'a' => [
'href' => [],
'target' => [],
],
]
);
?>
</div>
<?php
if ($echo) {
ob_end_flush();
return '';
} else {
return ob_get_clean();
}
}
/**
* Render form config fields
*
* @param bool $echo Echo or return
*
* @return string
*/
public function renderConfigFields($echo = true)
{
return TplMng::getInstance()->render(
'ftpaddon/configs/ftp',
[
'storage' => $this,
'server' => $this->config['server'],
'port' => $this->config['port'],
'username' => $this->config['username'],
'password' => $this->config['password'],
'storageFolder' => $this->config['storage_folder'],
'maxPackages' => $this->config['max_packages'],
'timeout' => $this->config['timeout_in_secs'],
'useCurl' => $this->config['use_curl'],
'isPassive' => $this->config['passive_mode'],
'useSSL' => $this->config['ssl'],
],
$echo
);
}
/**
* Update data from http request, this method don't save data, just update object properties
*
* @param string $message Message
*
* @return bool True if success and all data is valid, false otherwise
*/
public function updateFromHttpRequest(&$message = '')
{
if ((parent::updateFromHttpRequest($message) === false)) {
return false;
}
$this->config['max_packages'] = SnapUtil::sanitizeIntInput(SnapUtil::INPUT_REQUEST, 'ftp_max_files', 10);
$this->config['server'] = SnapUtil::sanitizeTextInput(SnapUtil::INPUT_REQUEST, 'ftp_server', '');
$this->config['port'] = SnapUtil::sanitizeIntInput(SnapUtil::INPUT_REQUEST, 'ftp_port', 10);
$this->config['username'] = SnapUtil::sanitizeTextInput(SnapUtil::INPUT_REQUEST, 'ftp_username', '');
$password = SnapUtil::sanitizeTextInput(SnapUtil::INPUT_REQUEST, 'ftp_password', '');
$password2 = SnapUtil::sanitizeTextInput(SnapUtil::INPUT_REQUEST, 'ftp_password2', '');
if (strlen($password) > 0) {
if ($password !== $password2) {
$message = __('Passwords do not match', 'duplicator-pro');
return false;
}
$this->config['password'] = $password;
}
$this->config['storage_folder'] = self::getSanitizedInputFolder('_ftp_storage_folder', 'add');
$this->config['timeout_in_secs'] = max(10, SnapUtil::sanitizeIntInput(SnapUtil::INPUT_REQUEST, 'ftp_timeout_in_secs', 15));
$this->config['use_curl'] = SnapUtil::sanitizeBoolInput(SnapUtil::INPUT_REQUEST, '_ftp_use_curl', false);
$this->config['ssl'] = SnapUtil::sanitizeBoolInput(SnapUtil::INPUT_REQUEST, '_ftp_ssl', false);
$this->config['passive_mode'] = SnapUtil::sanitizeBoolInput(SnapUtil::INPUT_REQUEST, '_ftp_passive_mode', false);
$errorMsg = '';
if ($this->getAdapter()->initialize($errorMsg) === false) {
$message = sprintf(
__('Failed to connect to FTP server with message: %1$s', 'duplicator-pro'),
$errorMsg
);
return false;
}
$message = sprintf(
__('FTP Storage Updated - Server %1$s, Folder %2$s was created.', 'duplicator-pro'),
$this->config['server'],
$this->getStorageFolder()
);
return true;
}
/**
* Register storage type
*
* @return void
*/
public static function registerType()
{
parent::registerType();
add_action('duplicator_update_global_storage_settings', function () {
$dGlobal = DynamicGlobalEntity::getInstance();
foreach (static::getDefaultSettings() as $key => $default) {
$value = SnapUtil::sanitizeIntInput(SnapUtil::INPUT_REQUEST, $key, $default);
$dGlobal->setVal($key, $value);
}
$dGlobal->save();
});
}
/**
* Get default settings
*
* @return array<string, scalar>
*/
protected static function getDefaultSettings()
{
return ['ftp_upload_chunksize_in_mb' => self::DEFAULT_UPLOAD_CHUNK_SIZE_IN_MB];
}
/**
* Render the settings page for this storage.
*
* @return void
*/
public static function renderGlobalOptions()
{
$values = self::getDefaultSettings();
$dGlobal = DynamicGlobalEntity::getInstance();
foreach ($values as $key => $default) {
$values[$key] = $dGlobal->getVal($key, $default);
}
?>
<h3 class="title"><?php esc_html_e("FTP", 'duplicator-pro') ?></h3>
<hr size="1" />
<table class="form-table">
<tr valign="top">
<th scope="row"><label><?php esc_html_e("Upload Size (MB)", 'duplicator-pro'); ?></label></th>
<td>
<input class="dup-narrow-input"
type="number"
min="<?php echo self::MIN_UPLOAD_CHUNK_SIZE_IN_MB; ?>"
max="<?php echo self::MAX_UPLOAD_CHUNK_SIZE_IN_MB; ?>"
name="ftp_upload_chunksize_in_mb"
id="ftp_upload_chunksize_in_mb"
data-parsley-required
data-parsley-type="number"
data-parsley-errors-container="#ftp_upload_chunksize_in_mb_error_container"
value="<?php echo (int) $values['ftp_upload_chunksize_in_mb']; ?>" />
<div id="ftp_upload_chunksize_in_mb_error_container" class="duplicator-error-container"></div>
<p class="description">
<?php esc_html_e('How much should be uploaded to the server per attempt.', 'duplicator-pro'); ?>
<?php echo esc_html(sprintf(__('Min size %smb.', 'duplicator-pro'), self::MIN_UPLOAD_CHUNK_SIZE_IN_MB)); ?>
</p>
</td>
</tr>
</table>
<?php
}
}

1035
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/ftpaddon/src/Models/FTPStorageAdapter.php Normal file
View File

File diff suppressed because it is too large Load Diff

385
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/ftpaddon/src/Models/SFTPStorage.php Normal file
View File

@@ -0,0 +1,385 @@
<?php
/**
*
* @package Duplicator
* @copyright (c) 2022, Snap Creek LLC
*/
namespace Duplicator\Addons\FtpAddon\Models;
use Duplicator\Core\Views\TplMng;
use Duplicator\Libs\Snap\SnapUtil;
use Duplicator\Models\Storages\AbstractStorageEntity;
use Exception;
class SFTPStorage extends AbstractStorageEntity
{
const MIN_UPLOAD_CHUNK_SIZE_IN_MB = 1;
const DEFAULT_UPLOAD_CHUNK_SIZE_IN_MB = 5;
const MAX_UPLOAD_CHUNK_SIZE_IN_MB = 100;
/**
* Get stoage adapter
*
* @return SFTPStorageAdapter
*/
protected function getAdapter()
{
return new SFTPStorageAdapter(
$this->config['server'],
$this->config['port'],
$this->config['username'],
$this->config['password'],
$this->config['storage_folder'],
$this->config['private_key'],
$this->config['private_key_password'],
$this->config['timeout_in_secs']
);
}
/**
* Get default config
*
* @return array<string,scalar>
*/
protected static function getDefaultConfig()
{
$config = parent::getDefaultConfig();
$config = array_merge(
$config,
[
'server' => '',
'port' => 22,
'username' => '',
'password' => '',
'private_key' => '',
'private_key_password' => '',
'timeout_in_secs' => 15,
]
);
return $config;
}
/**
* Serialize
*
* Wakeup method.
*
* @return void
*/
public function __wakeup()
{
parent::__wakeup();
if ($this->legacyEntity) {
// Old storage entity
$this->legacyEntity = false;
// Make sure the storage type is right from the old entity
$this->storage_type = $this->getSType();
$this->config = [
'server' => $this->sftp_server,
'port' => $this->sftp_port,
'username' => $this->sftp_username,
'password' => $this->sftp_password,
'private_key' => $this->sftp_private_key,
'private_key_password' => $this->sftp_private_key_password,
'storage_folder' => '/' . ltrim($this->sftp_storage_folder, '/\\'),
'max_packages' => $this->sftp_max_files,
'timeout_in_secs' => $this->sftp_timeout_in_secs,
];
// reset old values
$this->sftp_server = '';
$this->sftp_port = 22;
$this->sftp_username = '';
$this->sftp_password = '';
$this->sftp_private_key = '';
$this->sftp_private_key_password = '';
$this->sftp_storage_folder = '';
$this->sftp_max_files = 10;
$this->sftp_timeout_in_secs = 15;
$this->sftp_disable_chunking_mode = false;
}
// For legacy entities, we need to make sure the config is up to date
$this->config['port'] = (int) $this->config['port'];
$this->config['max_packages'] = (int) $this->config['max_packages'];
$this->config['timeout_in_secs'] = (int) $this->config['timeout_in_secs'];
}
/**
* Return the storage type
*
* @return int
*/
public static function getSType()
{
return 5;
}
/**
* Returns the FontAwesome storage type icon.
*
* @return string Returns the font-awesome icon
*/
public static function getStypeIcon()
{
return '<i class="fas fa-network-wired fa-fw"></i>';
}
/**
* Returns the storage type name.
*
* @return string
*/
public static function getStypeName()
{
return __('SFTP', 'duplicator-pro');
}
/**
* Get storage location string
*
* @return string
*/
public function getLocationString()
{
return $this->config['server'] . ":" . $this->config['port'];
}
/**
* Get priority, used to sort storages.
* 100 is neutral value, 0 is the highest priority
*
* @return int
*/
public static function getPriority()
{
return 90;
}
/**
* Check if storage is supported
*
* @return bool
*/
public static function isSupported()
{
return extension_loaded('gmp');
}
/**
* Get supported notice, displayed if storage isn't supported
*
* @return string html string or empty if storage is supported
*/
public static function getNotSupportedNotice()
{
if (static::isSupported()) {
return '';
}
return sprintf(
_x(
'SFTP requires the %1$sgmp extension%2$s. Please contact your host to install.',
'1: <a> tag, 2: </a> tag',
'duplicator-pro'
),
'<a href="http://php.net/manual/en/book.gmp.php" target="_blank">',
'</a>'
);
}
/**
* Check if storage is valid
*
* @return bool Return true if storage is valid and ready to use, false otherwise
*/
public function isValid()
{
return $this->getAdapter()->isValid();
}
/**
* Get action key text
*
* @param string $key Key name (action, pending, failed, cancelled, success)
*
* @return string
*/
protected function getActionKeyText($key)
{
switch ($key) {
case 'action':
return sprintf(
__('Transferring to SFTP server %1$s in folder:<br/> <i>%2$s</i>', "duplicator-pro"),
$this->config['server'],
$this->getStorageFolder()
);
case 'pending':
return sprintf(
__('Transfer to SFTP server %1$s in folder %2$s is pending', "duplicator-pro"),
$this->config['server'],
$this->getStorageFolder()
);
case 'failed':
return sprintf(
__('Failed to transfer to SFTP server %1$s in folder %2$s', "duplicator-pro"),
$this->config['server'],
$this->getStorageFolder()
);
case 'cancelled':
return sprintf(
__('Cancelled before could transfer to SFTP server:<br/>%1$s in folder %2$s', "duplicator-pro"),
$this->config['server'],
$this->getStorageFolder()
);
case 'success':
return sprintf(
__('Transferred package to SFTP server:<br/>%1$s in folder %2$s', "duplicator-pro"),
$this->config['server'],
$this->getStorageFolder()
);
default:
throw new Exception('Invalid key');
}
}
/**
* List quick view
*
* @param bool $echo Echo or return
*
* @return string
*/
public function getListQuickView($echo = true)
{
ob_start();
?>
<div>
<label><?php esc_html_e('Server', 'duplicator-pro'); ?>:</label>
<?php echo esc_html($this->config['server']); ?>: <?php echo intval($this->config['port']); ?> <br/>
<label><?php esc_html_e('Location', 'duplicator-pro') ?>:</label>
<?php
echo wp_kses(
$this->getHtmlLocationLink(),
[
'a' => [
'href' => [],
'target' => [],
],
]
);
?>
</div>
<?php
if ($echo) {
ob_end_flush();
return '';
} else {
return ob_get_clean();
}
}
/**
* Render form config fields
*
* @param bool $echo Echo or return
*
* @return string
*/
public function renderConfigFields($echo = true)
{
return TplMng::getInstance()->render(
'ftpaddon/configs/sftp',
[
'storage' => $this,
'server' => $this->config['server'],
'port' => $this->config['port'],
'username' => $this->config['username'],
'password' => $this->config['password'],
'privateKey' => $this->config['private_key'],
'privateKeyPwd' => $this->config['private_key_password'],
'storageFolder' => $this->config['storage_folder'],
'maxPackages' => $this->config['max_packages'],
'timeout' => $this->config['timeout_in_secs'],
],
$echo
);
}
/**
* Get upload chunk size in bytes
*
* @return int bytes
*/
public function getUploadChunkSize()
{
return -1;
}
/**
* Get upload chunk timeout in seconds
*
* @return int timeout in microseconds, 0 unlimited
*/
public function getUploadChunkTimeout()
{
return (int) ($this->config['timeout_in_secs'] <= 0 ? 0 : $this->config['timeout_in_secs'] * SECONDS_IN_MICROSECONDS);
}
/**
* Update data from http request, this method don't save data, just update object properties
*
* @param string $message Message
*
* @return bool True if success and all data is valid, false otherwise
*/
public function updateFromHttpRequest(&$message = '')
{
if ((parent::updateFromHttpRequest($message) === false)) {
return false;
}
$this->config['max_packages'] = SnapUtil::sanitizeIntInput(SnapUtil::INPUT_REQUEST, 'sftp_max_files', 10);
$this->config['server'] = SnapUtil::sanitizeTextInput(SnapUtil::INPUT_REQUEST, 'sftp_server', '');
$this->config['port'] = SnapUtil::sanitizeIntInput(SnapUtil::INPUT_REQUEST, 'sftp_port', 10);
$this->config['username'] = SnapUtil::sanitizeTextInput(SnapUtil::INPUT_REQUEST, 'sftp_username', '');
$password = SnapUtil::sanitizeTextInput(SnapUtil::INPUT_REQUEST, 'sftp_password', '');
$password2 = SnapUtil::sanitizeTextInput(SnapUtil::INPUT_REQUEST, 'sftp_password2', '');
$this->config['private_key'] = SnapUtil::sanitizeDefaultInput(SnapUtil::INPUT_REQUEST, 'sftp_private_key', '');
$keyPassword = SnapUtil::sanitizeTextInput(SnapUtil::INPUT_REQUEST, 'sftp_private_key_password', '');
$keyPassword2 = SnapUtil::sanitizeTextInput(SnapUtil::INPUT_REQUEST, 'sftp_private_key_password2', '');
if (strlen($password) > 0) {
if ($password !== $password2) {
$message = __('Passwords do not match', 'duplicator-pro');
return false;
}
$this->config['password'] = $password;
} elseif (strlen($keyPassword) > 0) {
if ($keyPassword !== $keyPassword2) {
$message = __('Priva key Passwords do not match', 'duplicator-pro');
return false;
}
$this->config['private_key_password'] = $keyPassword;
}
$this->config['storage_folder'] = self::getSanitizedInputFolder('_sftp_storage_folder', 'add');
$this->config['timeout_in_secs'] = max(10, SnapUtil::sanitizeIntInput(SnapUtil::INPUT_REQUEST, 'sftp_timeout_in_secs', 15));
$errorMsg = '';
if ($this->getAdapter()->initialize($errorMsg) === false) {
$message = sprintf(
__('Failed to connect to SFTP server with message: %1$s', 'duplicator-pro'),
$errorMsg
);
return false;
}
$message = sprintf(
__('SFTP Storage Updated - Server %1$s, Folder %2$s was created.', 'duplicator-pro'),
$this->config['server'],
$this->getStorageFolder()
);
return true;
}
}

779
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/ftpaddon/src/Models/SFTPStorageAdapter.php Normal file
View File

@@ -0,0 +1,779 @@
<?php
/**
* @package Duplicator
* @copyright (c) 2022, Snapcreek LLC
*/
namespace Duplicator\Addons\FtpAddon\Models;
use Exception;
use Duplicator\Libs\Snap\SnapIO;
use Duplicator\Models\Storages\AbstractStorageAdapter;
use Duplicator\Models\Storages\StoragePathInfo;
use VendorDuplicator\phpseclib3\Crypt\Common\PrivateKey;
use VendorDuplicator\phpseclib3\Crypt\PublicKeyLoader;
use VendorDuplicator\phpseclib3\Net\SFTP;
/**
* SFTP class adapter
*/
class SFTPStorageAdapter extends AbstractStorageAdapter
{
/** @var int */
const DEFAULT_CHUNK_SIZE = 2 * 1024 * 1024;
/** @var string */
protected $server = '';
/** @var int */
protected $port = 22;
/** @var string */
protected $username = '';
/** @var string */
protected $password = '';
/** @var string */
protected $root = '';
/** @var string */
protected $privateKey = '';
/** @var string */
protected $privateKeyPassword = '';
/** @var int */
protected $timeout = 15;
/** @var resource */
private $sourceFileHandle = null;
/** @var string */
private $lastSourceFilePath = '';
/** @var resource */
private $destFileHandle = null;
/** @var string */
private $lastDestFilePath = '';
/** @var ?SFTP */
private $connection = null;
/**
* Class contructor
*
* @param string $server hosting domain or ip address
* @param int $port hosting port
* @param string $username hosting username
* @param string $password hosting password
* @param string $root hosting root path
* @param string $privateKey hosting private key
* @param string $privateKeyPassword hosting private key password
* @param int $timeout hosting timeout
*/
public function __construct(
$server,
$port = 22,
$username = '',
$password = '',
$root = '',
$privateKey = '',
$privateKeyPassword = '',
$timeout = 15
) {
$this->server = $server;
$this->port = (int) $port;
$this->username = $username;
$this->password = $password;
$this->root = SnapIO::trailingslashit($root);
$this->privateKey = $privateKey;
$this->privateKeyPassword = $privateKeyPassword;
$this->timeout = (int) $timeout;
}
/**
* Initialize the storage on creation.
*
* @param string $errorMsg The error message if storage is invalid.
*
* @return bool true on success or false on failure.
*/
public function initialize(&$errorMsg = '')
{
if (!$this->isDir('/') && !$this->createDir('/')) {
$errorMsg = 'Could not create root directory';
return false;
}
return true;
}
/**
* Destroy the storage on deletion.
*
* @return bool true on success or false on failure.
*/
public function destroy()
{
return $this->delete('/', true);
}
/**
* Check if storage is valid and ready to use.
*
* @param string $errorMsg The error message if storage is invalid.
*
* @return bool
*/
public function isValid(&$errorMsg = '')
{
if (!$this->isConnectionInfoValid($errorMsg)) {
return false;
}
if ($this->getConnection($errorMsg) === null) {
return false;
}
if (!$this->isDir('/')) {
$errorMsg = 'Root path is invalid';
return false;
}
return true;
}
/**
* Check if connection info is valid
*
* @param string $errorMsg error message
*
* @return bool true if connection info is valid, false otherwise
*/
private function isConnectionInfoValid(&$errorMsg = '')
{
try {
if (strlen($this->server) == 0) {
throw new Exception('Server name is required to make sftp connection');
}
if ($this->port < 1) {
throw new Exception('Server port is required to make sftp connection');
}
if (strlen($this->username) == 0) {
throw new Exception('Username is required to make sftp connection');
}
if (strlen($this->password) == 0 && strlen($this->privateKey) == 0) {
throw new Exception('You should provide either sftp user pasword or the private key to make sftp connection');
}
if (strlen($this->privateKey) > 0 && strlen($this->privateKeyPassword) == 0) {
throw new Exception('You should provide private key password');
}
} catch (Exception $e) {
$errorMsg = $e->getMessage();
return false;
}
return true;
}
/**
* Create the directory specified by pathname, recursively if necessary.
*
* @param string $path The directory path.
*
* @return bool true on success or false on failure.
*/
public function realCreateDir($path)
{
if (($conn = $this->getConnection()) === null) {
return false;
}
if ($this->isDir($path)) {
return true;
}
$path = $this->getFullPath($path, true);
try {
return $conn->mkdir($path, -1, true) !== false;
} catch (Exception $e) {
return false;
}
}
/**
* Create file with content.
*
* @param string $path The path to file.
* @param string $content The content of file.
*
* @return false|int The number of bytes that were written to the file, or false on failure.
*/
public function realCreateFile($path, $content)
{
if (($conn = $this->getConnection()) === null) {
return false;
}
if (($fullPath = $this->getFullPath($path)) === false) {
return false;
}
try {
$parentDir = dirname($path);
if ($this->createDir($parentDir) === false) {
return false;
}
if ($conn->put($fullPath, $content) === false) {
return false;
}
return strlen($content);
} catch (Exception $e) {
return false;
}
}
/**
* Get file content.
*
* @param string $path The path to file.
*
* @return string|false The content of file or false on failure.
*/
public function getFileContent($path)
{
if (($conn = $this->getConnection()) === null) {
return false;
}
if (($path = $this->getFullPath($path)) === false) {
return false;
}
try {
return $conn->get($path);
} catch (Exception $e) {
return false;
}
}
/**
* Move and/or rename a file or directory.
*
* @param string $oldPath Relative storage path
* @param string $newPath Relative storage path
*
* @return bool true on success or false on failure.
*/
public function realMove($oldPath, $newPath)
{
if (($conn = $this->getConnection()) === null) {
return false;
}
if (($oldPath = $this->getFullPath($oldPath)) === false) {
return false;
}
if (($newPath = $this->getFullPath($newPath)) === false) {
return false;
}
try {
return $conn->rename($oldPath, $newPath);
} catch (Exception $e) {
return false;
}
}
/**
* Get path info.
*
* @param string $path Relative storage path, if empty, return root path info.
*
* @return StoragePathInfo|false The path info or false if path is invalid.
*/
public function getRealPathInfo($path)
{
if (($conn = $this->getConnection()) === null) {
return false;
}
$fullPath = $this->getFullPath($path, true);
try {
$info = $conn->stat($fullPath);
if ($info === false) {
throw new Exception('Could not get path info');
}
$pathInfo = new StoragePathInfo();
$pathInfo->exists = true;
$pathInfo->path = $path;
$pathInfo->isDir = $info['type'] === 2;
$pathInfo->size = $pathInfo->isDir ? 0 : $info['size'];
$pathInfo->modified = $info['mtime'];
$pathInfo->created = isset($info['ctime']) ? $info['ctime'] : $info['mtime'];
return $pathInfo;
} catch (Exception $e) {
$pathInfo = new StoragePathInfo();
$pathInfo->path = $path;
return $pathInfo;
}
}
/**
* Get the list of files and directories inside the specified path.
*
* @param string $path Relative storage path, if empty, scan root path.
* @param bool $files If true, add files to the list. Default to true.
* @param bool $folders If true, add folders to the list. Default to true.
*
* @return string[] The list of files and directories, empty array if path is invalid.
*/
public function scanDir($path, $files = true, $folders = true)
{
if (($conn = $this->getConnection()) === null) {
return [];
}
$path = $this->getFullPath($path, true);
try {
$list = $conn->nlist($path);
if ($list === false) {
return [];
}
$result = [];
foreach ($list as $item) {
if ($item === '.' || $item === '..') {
continue;
}
$itemPath = SnapIO::trailingslashit($path) . $item;
if ($conn->is_dir($itemPath)) {
if ($folders) {
$result[] = $item;
}
} else {
if ($files) {
$result[] = $item;
}
}
}
return $result;
} catch (Exception $e) {
return [];
}
}
/**
* Check if directory is empty.
*
* @param string $path The folder path
* @param string[] $filters Filters to exclude files and folders from the check, if start and end with /, use regex.
*
* @return bool True is ok, false otherwise
*/
public function isDirEmpty($path, $filters = [])
{
if ($this->isDir($path) === false) {
return false;
}
$regexFilters = [];
$normalFilters = [];
foreach ($filters as $filter) {
if (preg_match('/^\/.*\/$/', $filter) === 1) {
$regexFilters[] = $filter;
} else {
$normalFilters[] = $filter;
}
}
$contents = $this->scanDir($path);
foreach ($contents as $item) {
if (in_array($item, $normalFilters)) {
continue;
}
foreach ($regexFilters as $regexFilter) {
if (preg_match($regexFilter, $item) === 1) {
continue 2;
}
}
return false;
}
return true;
}
/**
* Copy local file to storage, partial copy is supported.
* If destination file exists, it will be overwritten.
* If offset is less than the destination file size, the file will be truncated.
*
* @param string $sourceFile The source file full path
* @param string $storageFile Storage destination path
* @param int<0,max> $offset The offset where the data starts.
* @param int $length The maximum number of bytes read. Default to -1 (read all the remaining buffer).
* @param int $timeout The timeout for the copy operation in microseconds. Default to 0 (no timeout).
* @param array<string,mixed> $extraData Extra data to pass to copy function and updated during copy.
* Used for storages that need to maintain persistent data during copy intra-session.
*
* @return false|int The number of bytes that were written to the file, or false on failure.
*/
protected function realCopyToStorage($sourceFile, $storageFile, $offset = 0, $length = -1, $timeout = 0, &$extraData = [])
{
$startTime = microtime(true);
if (($conn = $this->getConnection()) === null) {
return false;
}
if (($storageFileFullPath = $this->getFullPath($storageFile)) === false) {
return false;
}
$parentDir = dirname($storageFile);
if ($offset === 0 && !$this->createDir($parentDir)) {
return false;
}
//Uplaod file at once without any other operation
if (($timeout === 0 && $offset === 0 && $length < 0) || filesize($sourceFile) < $length) {
if (($content = file_get_contents($sourceFile)) === false) {
return false;
}
return $this->createFile($storageFile, $content);
}
if (($sourceFileHandle = $this->getSourceFileHandle($sourceFile)) === false) {
return false;
}
if (@fseek($sourceFileHandle, $offset) === -1) {
return false;
}
$bytesWritten = 0;
$length = $length < 0 ? self::DEFAULT_CHUNK_SIZE : $length;
try {
$result = $conn->put(
$storageFileFullPath,
function ($size) use ($timeout, $startTime, &$bytesWritten, $sourceFileHandle, $length) {
if ($timeout !== 0 && (microtime(true) - $startTime) * SECONDS_IN_MICROSECONDS > $timeout) {
return null;
}
if ($timeout === 0 && $bytesWritten >= $length) {
return null;
}
if (feof($sourceFileHandle)) {
return null;
}
if (($data = @fread($sourceFileHandle, $size)) === false) {
return null;
}
return $data;
},
SFTP::SOURCE_CALLBACK | SFTP::RESUME,
$offset,
-1,
function ($sent) use (&$bytesWritten) {
$bytesWritten = $sent;
}
);
if ($result === false) {
return false;
}
} catch (Exception $e) {
return false;
}
return $timeout === 0 ? $length : $bytesWritten;
}
/**
* Copy storage file to local file, partial copy is supported.
* If destination file exists, it will be overwritten.
* If offset is less than the destination file size, the file will be truncated.
*
* @param string $storageFile The storage file path
* @param string $destFile The destination local file full path
* @param int<0,max> $offset The offset where the data starts.
* @param int $length The maximum number of bytes read. Default to -1 (read all the remaining buffer).
* @param int $timeout The timeout for the copy operation in microseconds. Default to 0 (no timeout).
* @param array<string,mixed> $extraData Extra data to pass to copy function and updated during copy.
* Used for storages that need to maintain persistent data during copy intra-session.
*
* @return false|int The number of bytes that were written to the file, or false on failure.
*/
public function copyFromStorage($storageFile, $destFile, $offset = 0, $length = -1, $timeout = 0, &$extraData = [])
{
$startTime = microtime(true);
if (($conn = $this->getConnection()) === null) {
return false;
}
if (($fullPath = $this->getFullPath($storageFile)) === false) {
return false;
}
if (wp_mkdir_p(dirname($destFile)) == false) {
return false;
}
if ($offset === 0 && @file_exists($destFile) && !@unlink($destFile)) {
return false;
}
if (!$this->isFile($storageFile)) {
return false;
}
if ($offset === 0 && $length < 0) {
if (($content = $this->getFileContent($storageFile)) === false) {
return false;
}
return @file_put_contents($destFile, $content);
}
if (($handle = $this->getDestFileHandle($destFile)) === false) {
return false;
}
$bytesWritten = 0;
$length = $length < 0 ? self::DEFAULT_CHUNK_SIZE : $length;
try {
do {
$content = $conn->get($fullPath, false, $offset, $length);
if (
$content === false ||
@fseek($handle, $offset) === -1 ||
@fwrite($handle, $content) === false
) {
return false;
}
if ($timeout === 0) {
return $length;
}
$bytesWritten += strlen($content);
$offset += strlen($content);
} while (self::getElapsedTime($startTime) < $timeout && $content !== false);
} catch (Exception $e) {
return false;
}
return $bytesWritten;
}
/**
* Returns an SFTP object
*
* @param string $errorMsg error message
*
* @return ?SFTP
*/
private function getConnection(&$errorMsg = '')
{
if ($this->connection instanceof SFTP) {
return $this->connection;
}
try {
if (!$this->isConnectionInfoValid($errorMsg)) {
throw new Exception($errorMsg);
}
$this->connection = new SFTP($this->server, $this->port);
if (strlen($this->privateKey) > 0) {
if (($key = $this->getPrivateKey()) === null) {
throw new Exception('Invalid private key');
}
if (!$this->connection->login($this->username, $key)) {
throw new Exception('Invalid username or private key');
}
} else {
if (!$this->connection->login($this->username, $this->password)) {
throw new Exception('Invalid username or password');
}
}
} catch (Exception $e) {
if ($this->connection !== null && $this->connection->isConnected()) {
$this->connection->disconnect();
}
$this->connection = null;
$errorMsg = $e->getMessage();
return null;
}
return $this->connection;
}
/**
* Set an SFTP Private Key
*
* @return ?PrivateKey return key object or null
*/
protected function getPrivateKey()
{
if (strlen($this->privateKey) == 0) {
return null;
}
$password = strlen($this->privateKeyPassword) > 0 ? $this->privateKeyPassword : false;
$key = PublicKeyLoader::load($this->privateKey, $password);
if ($key instanceof PrivateKey) {
return $key;
} else {
return null;
}
}
/**
* Delete reletative path from storage root.
*
* @param string $path The path to delete. (Accepts directories and files)
* @param bool $recursive Allows the deletion of nested directories specified in the pathname. Default to false.
*
* @return bool true on success or false on failure.
*/
public function realDelete($path, $recursive = false)
{
if (($conn = $this->getConnection()) === null) {
return false;
}
if ($this->exists($path) === false) {
return true;
}
$fullPath = $this->getFullPath($path, true);
try {
// have to use hack below because phpseclib doesn't work well with
// directories in none recursive mode
$isDir = $this->isDir($path);
$isEmptyDir = $isDir && $this->isDirEmpty($path);
if ($isDir) {
if ($isEmptyDir === false && $recursive === false) {
return false;
}
return $conn->delete($fullPath, true);
} else {
return $conn->delete($fullPath);
}
} catch (Exception $e) {
return false;
}
}
/**
* Return the full path of storage from relative path.
*
* @param string $path The relative storage path
* @param bool $acceptEmpty If true, return root path if path is empty. Default to false.
*
* @return string|false The full path or false if path is invalid.
*/
protected function getFullPath($path, $acceptEmpty = false)
{
$path = ltrim((string) $path, '/\\');
if (strlen($path) === 0) {
return $acceptEmpty ? SnapIO::untrailingslashit($this->root) : false;
}
return $this->root . $path;
}
/**
* Returns the source file handle
*
* @param string $destFilePath The source file path
*
* @return resource|false returns the file handle or false on failure
*/
private function getDestFileHandle($destFilePath)
{
if ($this->lastDestFilePath === $destFilePath) {
return $this->destFileHandle;
}
if (is_resource($this->destFileHandle)) {
fclose($this->destFileHandle);
}
if (($this->destFileHandle = @fopen($destFilePath, 'cb')) === false) {
return false;
}
$this->lastDestFilePath = $destFilePath;
return $this->destFileHandle;
}
/**
* Returns the source file handle
*
* @param string $sourceFilePath The source file path
*
* @return resource|false
*/
private function getSourceFileHandle($sourceFilePath)
{
if ($this->lastSourceFilePath === $sourceFilePath) {
return $this->sourceFileHandle;
}
if (is_resource($this->sourceFileHandle)) {
@fclose($this->sourceFileHandle);
}
if (($this->sourceFileHandle = @fopen($sourceFilePath, 'r')) === false) {
return false;
}
$this->lastSourceFilePath = $sourceFilePath;
return $this->sourceFileHandle;
}
/**
* Get elapsed time in microseconds
*
* @param float $startTime start time
*
* @return float
*/
private function getElapsedTime($startTime)
{
return (microtime(true) - $startTime) * SECONDS_IN_MICROSECONDS;
}
/**
* Class destructor
*
* @return void
*/
public function __destruct()
{
if ($this->connection !== null && $this->connection->isConnected()) {
$this->connection->disconnect();
}
}
}

89
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/ftpaddon/src/Utils/FTPUtils.php Normal file
View File

@@ -0,0 +1,89 @@
<?php
/**
* @package Duplicator
* @copyright (c) 2022, Snapcreek LLC
*/
namespace Duplicator\Addons\FtpAddon\Utils;
class FTPUtils
{
const SYS_TYPE_UNIX = 'UNIX';
const SYS_TYPE_WINDOWS_NT = 'WINDOWS_NT';
/**
* Parses a raw list item string into an array
*
* @param string $rawListString Raw list string
* @param string $systemType System type (UNIX or WINDOWS_NT)
*
* @return false|array{name: string, size: int, modified: int, created: int, isDir: bool}|false
*/
public static function parseRawListString($rawListString, $systemType)
{
switch (strtoupper($systemType)) {
case self::SYS_TYPE_UNIX:
return self::parseUnixRawListString($rawListString);
case self::SYS_TYPE_WINDOWS_NT:
return self::parseWindowsRawListString($rawListString);
default:
return false;
}
}
/**
* Returns the info in the raw list item for Windows
*
* @param string $rawListString Raw list string
*
* @return false|array{name: string, size: int, modified: int, created: int, isDir: bool}|false
*/
private static function parseWindowsRawListString($rawListString)
{
//Regex below gets info from raw string on Windows systems
//Dir: 01-01-70 12:00AM <DIR> folder
//File: 01-01-70 12:00AM 4096 file.txt
//Groups: 1 3 4
$regex = '/^(\d{2}-\d{2}-\d{2,4}\s+\d{1,2}:\d{1,2}(?:AM|PM))\s+(?:<DIR>|(\d+))\s+(.+)$/';
if (preg_match($regex, $rawListString, $matches) !== 1) {
return false;
}
$info = [];
$info['name'] = $matches[4];
$info['isDir'] = strtoupper($matches[3]) === '<DIR>';
$info['size'] = $info['isDir'] ? 0 : (int) $matches[3];
$info['modified'] = strtotime($matches[1]);
$info['created'] = $info['modified'];
return $info;
}
/**
* Returns the info in the raw list item for Unix
*
* @param string $rawListString Raw list string
*
* @return false|array{name: string, size: int, modified: int, created: int, isDir: bool}|false
*/
private static function parseUnixRawListString($rawListString)
{
//Regex below gets info from raw string on UNIX systems
//Example: drwxr-xr-x 2 user group 4096 Jan 1 1970 folder
//Groups: 1 2 3 4 5 6 7
$regex = '/^([drwx\-]{10})\s+(\d+)\s+(\S+)\s+(\S+)\s+(\d+)\s+(\w{3}\s+\d{1,2}\s+\d{1,2}:\d{1,2}|\w{3}\s+\d{1,2}\s+\d{4})\s+(.+)$/';
if (preg_match($regex, $rawListString, $matches) !== 1) {
return false;
}
$info = [];
$info['name'] = $matches[7];
$info['isDir'] = $matches[1][0] === 'd';
$info['size'] = $info['isDir'] ? 0 : (int) $matches[5];
$info['modified'] = strtotime($matches[6]);
$info['created'] = $info['modified'];
return $info;
}
}

251
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/ftpaddon/template/ftpaddon/configs/ftp.php Normal file
View File

@@ -0,0 +1,251 @@
<?php
/**
* Duplicator messages sections
*
* @package Duplicator
* @copyright (c) 2022, Snap Creek LLC
*/
use Duplicator\Addons\FtpAddon\Models\FTPStorage;
defined("ABSPATH") or die("");
/**
* Variables
*
* @var \Duplicator\Core\Controllers\ControllersManager $ctrlMng
* @var \Duplicator\Core\Views\TplMng $tplMng
* @var array<string, mixed> $tplData
* @var FTPStorage $storage
*/
$storage = $tplData["storage"];
/** @var string */
$server = $tplData["server"];
/** @var int */
$port = $tplData["port"];
/** @var string */
$username = $tplData["username"];
/** @var string */
$password = $tplData["password"];
/** @var string */
$storageFolder = $tplData["storageFolder"];
/** @var int */
$maxPackages = $tplData["maxPackages"];
/** @var int */
$timeout = $tplData["timeout"];
/** @var bool */
$useCurl = $tplData["useCurl"];
/** @var bool */
$isPassive = $tplData["isPassive"];
/** @var bool */
$useSSL = $tplData["useSSL"];
$tplMng->render('admin_pages/storages/parts/provider_head');
?>
<tr>
<td class="dpro-sub-title" colspan="2"><b><?php esc_html_e("Credentials", 'duplicator-pro'); ?></b></td>
</tr>
<tr>
<th scope="row"><label for="ftp_server"><?php esc_html_e("Server", 'duplicator-pro'); ?></label></th>
<td>
<input
id="ftp_server"
class="dup-empty-field-on-submit"
name="ftp_server"
type="text"
autocomplete="off"
value="<?php echo esc_attr($server); ?>"
data-parsley-errors-container="#ftp_server_error_container"
data-parsley-required="true"
>
<label for="ftp_server">
<?php esc_html_e("Port", 'duplicator-pro'); ?>
</label>
<input
name="ftp_port"
id="ftp_port"
type="number"
min="1"
max="65535"
style="width:75px"
value="<?php echo (int) $port; ?>"
data-parsley-errors-container="#ftp_server_error_container"
data-parsley-required="true"
data-parsley-type="number"
data-parsley-range="[1, 65535]"
>
<div id="ftp_server_error_container" class="duplicator-error-container"></div>
</td>
</tr>
<tr>
<th scope="row"><label for="ftp_username"><?php esc_html_e("Username", 'duplicator-pro'); ?></label></th>
<td>
<input
id="ftp_username"
class="dup-empty-field-on-submit"
name="ftp_username"
type="text"
autocomplete="off"
value="<?php echo esc_attr($username); ?>"
>
</td>
</tr>
<tr>
<th scope="row"><label for="ftp_password"><?php esc_html_e("Password", 'duplicator-pro'); ?></label></th>
<td>
<input
id="ftp_password"
name="ftp_password"
type="password"
class="dup-empty-field-on-submit"
placeholder="<?php echo esc_attr(str_repeat("*", strlen($password))); ?>"
autocomplete="off"
value=""
>
</td>
</tr>
<tr>
<th scope="row"><label for="ftp_password2"><?php esc_html_e("Retype Password", 'duplicator-pro'); ?></label></th>
<td>
<input
id="ftp_password2"
class="dup-empty-field-on-submit"
name="ftp_password2"
type="password"
placeholder="<?php echo esc_attr(str_repeat("*", strlen($password))); ?>"
autocomplete="off"
value=""
data-parsley-errors-container="#ftp_password2_error_container"
data-parsley-trigger="change"
data-parsley-equalto="#ftp_password"
data-parsley-equalto-message="<?php esc_html_e("Passwords do not match", 'duplicator-pro'); ?>"
><br/>
<div id="ftp_password2_error_container" class="duplicator-error-container"></div>
</td>
</tr>
<tr>
<td class="dpro-sub-title" colspan="2"><b><?php esc_html_e("Settings", 'duplicator-pro'); ?></b></td>
</tr>
<tr>
<th scope="row"><label for="_ftp_storage_folder"><?php esc_html_e("Storage Folder", 'duplicator-pro'); ?></label></th>
<td>
<input
id="_ftp_storage_folder"
name="_ftp_storage_folder"
type="text"
value="<?php echo esc_attr($storageFolder); ?>"
>
<p>
<i>
<?php
esc_html_e(
"Folder where packages will be stored. This should be unique for each web-site using Duplicator.",
'duplicator-pro'
); ?>
</i>
</p>
</td>
</tr>
<tr>
<th scope="row"><label for="ftp_max_files"><?php esc_html_e("Max Packages", 'duplicator-pro'); ?></label></th>
<td>
<label for="ftp_max_files">
<input
id="ftp_max_files"
name="ftp_max_files"
type="number"
value="<?php echo (int) $maxPackages; ?>"
min="0"
maxlength="4"
data-parsley-errors-container="#ftp_max_files_error_container"
data-parsley-required="true"
data-parsley-type="number"
data-parsley-min="0"
>
<?php esc_html_e("Number of packages to keep in folder.", 'duplicator-pro'); ?> <br/>
<i><?php esc_html_e("When this limit is exceeded, the oldest package will be deleted. Set to 0 for no limit. ", 'duplicator-pro'); ?></i>
</label>
<div id="ftp_max_files_error_container" class="duplicator-error-container"></div>
</td>
</tr>
<tr>
<th scope="row"><label for="ftp_timeout_in_secs"><?php esc_html_e("Timeout", 'duplicator-pro'); ?></label></th>
<td>
<label for="ftp_timeout_in_secs">
<input
id="ftp_timeout"
name="ftp_timeout_in_secs"
type="number"
min="10"
value="<?php echo (int) $timeout; ?>"
data-parsley-errors-container="#ftp_timeout_error_container"
data-parsley-required="true"
data-parsley-type="number"
data-parsley-min="10"
>
<label for="ftp_timeout_in_secs">
<?php esc_html_e("seconds", 'duplicator-pro'); ?>
</label>
<br>
<i>
<?php
esc_html_e(
"Do not modify this setting unless you know the expected result or have talked to support.",
'duplicator-pro'
); ?>
</i>
</label>
<div id="ftp_timeout_error_container" class="duplicator-error-container"></div>
</td>
</tr>
<tr>
<th scope="row"><label for="ftp_ssl"><?php esc_html_e("Explicit SSL", 'duplicator-pro'); ?></label></th>
<td>
<input name="_ftp_ssl" <?php checked($useSSL); ?> class="checkbox" value="1" type="checkbox" id="_ftp_ssl" >
<label for="_ftp_ssl"><?php esc_html_e("Enable", 'duplicator-pro'); ?></label>
</td>
</tr>
<tr>
<th scope="row"><label for="_ftp_passive_mode"><?php esc_html_e("Passive Mode", 'duplicator-pro'); ?></label></th>
<td>
<input
<?php checked($isPassive); ?>
class="checkbox"
value="1"
type="checkbox"
name="_ftp_passive_mode"
id="_ftp_passive_mode"
>
<label for="_ftp_passive_mode"><?php esc_html_e("Enable", 'duplicator-pro'); ?></label>
</td>
</tr>
<tr>
<th scope="row"><label for="_ftp_use_curl"><?php esc_html_e("cURL", 'duplicator-pro'); ?></label></th>
<td>
<input <?php checked($useCurl); ?> class="checkbox" value="1" type="checkbox" name="_ftp_use_curl" id="_ftp_use_curl">
<label for="_ftp_use_curl"><?php esc_html_e("Enable", 'duplicator-pro'); ?></label>
<p><i><?php esc_html_e("PHP cURL. Only check if connection test recommends it.", 'duplicator-pro'); ?></i></p>
</td>
</tr>
<tr>
<th scope="row"><label>&nbsp;</label></th>
<td>
<p>
<?php
echo wp_kses(
__(
"<b>Note:</b> This setting is for FTP and FTPS (FTP/SSL) only.
To use SFTP (SSH File Transfer Protocol) change the type dropdown above.",
'duplicator-pro'
),
array(
'b' => array(),
)
);
?>
</p>
</td>
</tr>
<?php $tplMng->render('admin_pages/storages/parts/provider_foot'); ?>

240
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/ftpaddon/template/ftpaddon/configs/sftp.php Normal file
View File

@@ -0,0 +1,240 @@
<?php
/**
* Duplicator messages sections
*
* @package Duplicator
* @copyright (c) 2022, Snap Creek LLC
*/
use Duplicator\Addons\FtpAddon\Models\SFTPStorage;
defined("ABSPATH") or die("");
/**
* Variables
*
* @var \Duplicator\Core\Controllers\ControllersManager $ctrlMng
* @var \Duplicator\Core\Views\TplMng $tplMng
* @var array<string, mixed> $tplData
* @var SFTPStorage $storage
*/
$storage = $tplData["storage"];
/** @var string */
$server = $tplData["server"];
/** @var int */
$port = $tplData["port"];
/** @var string */
$username = $tplData["username"];
/** @var string */
$password = $tplData["password"];
/** @var string */
$privateKey = $tplData["privateKey"];
/** @var string */
$privateKeyPwd = $tplData["privateKeyPwd"];
/** @var string */
$storageFolder = $tplData["storageFolder"];
/** @var int */
$maxPackages = $tplData["maxPackages"];
/** @var int */
$timeout = $tplData["timeout"];
$tplMng->render('admin_pages/storages/parts/provider_head');
?>
<tr>
<td class="dpro-sub-title" colspan="2"><b><?php esc_html_e("Credentials", 'duplicator-pro'); ?></b></td>
</tr>
<tr>
<th scope="row"><label for="sftp_server"><?php esc_html_e("Server", 'duplicator-pro'); ?></label></th>
<td>
<input id="sftp_server" class="dup-empty-field-on-submit" name="sftp_server"
data-parsley-errors-container="#sftp_server_error_container" type="text" a
utocomplete="off" value="<?php echo esc_attr($server); ?>">
<label for="sftp_server">
<?php esc_html_e("Port", 'duplicator-pro'); ?>
</label>
<input
name="sftp_port"
id="sftp_port"
data-parsley-errors-container="#sftp_server_error_container"
data-parsley-required="true"
data-parsley-type="number"
data-parsley-range="[1, 65535]"
type="number"
min="1"
max="65535"
style="width:75px"
value="<?php echo (int) $port; ?>"
>
<div id="sftp_server_error_container" class="duplicator-error-container"></div>
</td>
</tr>
<tr>
<th scope="row"><label for="sftp_username"><?php esc_html_e("Username", 'duplicator-pro'); ?></label></th>
<td><input id="sftp_username" class="dup-empty-field-on-submit" name="sftp_username"
type="text" autocomplete="off" value="<?php echo esc_attr($username); ?>" /></td>
</tr>
<tr>
<th scope="row"><label for="sftp_password"><?php esc_html_e("Password", 'duplicator-pro'); ?></label></th>
<td>
<input
id="sftp_password"
class="dup-empty-field-on-submit"
name="sftp_password"
type="password"
placeholder="<?php echo esc_attr(str_repeat("*", strlen($password))); ?>"
autocomplete="off"
value=""
>
</td>
</tr>
<tr>
<th scope="row"><label for="sftp_password2"><?php esc_html_e("Retype Password", 'duplicator-pro'); ?></label></th>
<td>
<input
id="sftp_password2"
class="dup-empty-field-on-submit"
name="sftp_password2"
type="password"
placeholder="<?php echo esc_attr(str_repeat("*", strlen($password))); ?>"
autocomplete="off"
value=""
data-parsley-errors-container="#sftp_password2_error_container"
data-parsley-trigger="change"
data-parsley-equalto="#sftp_password"
data-parsley-equalto-message="<?php esc_attr_e("Passwords do not match", 'duplicator-pro'); ?>"
><br/>
<div id="sftp_password2_error_container" class="duplicator-error-container"></div>
</td>
</tr>
<tr>
<th scope="row"><label for="sftp_private_key"><?php esc_html_e("Private Key (PuTTY)", 'duplicator-pro'); ?></label></th>
<td>
<input
id="sftp_private_key_file"
class="dup-empty-field-on-submit"
name="sftp_private_key_file"
onchange="DuplicatorReadPrivateKey(this);"
type="file"
accept="ppk"
value=""
data-parsley-errors-container="#sftp_private_key_error_container"
><br/>
<input type="hidden" name="sftp_private_key" id="sftp_private_key" value="<?php echo esc_attr($privateKey); ?>" />
<div id="sftp_private_key_error_container" class="duplicator-error-container"></div>
</td>
</tr>
<tr>
<th scope="row"><label for="sftp_private_key_password"><?php esc_html_e("Private Key Password", 'duplicator-pro'); ?></label></th>
<td>
<input
id="sftp_private_key_password"
class="dup-empty-field-on-submit"
name="sftp_private_key_password"
type="password"
placeholder="<?php echo esc_attr(str_repeat("*", strlen($privateKeyPwd))); ?>"
autocomplete="off"
value=""
data-parsley-errors-container="#sftp_private_key_password_error_container"
>
<br/>
<div id="sftp_private_key_password_error_container" class="duplicator-error-container"></div>
</td>
</tr>
<tr>
<th scope="row"><label for="sftp_private_key_password2"><?php esc_html_e("Private Key Retype Password", 'duplicator-pro'); ?></label></th>
<td>
<input
id="sftp_private_key_password2"
class="dup-empty-field-on-submit"
name="sftp_private_key_password2"
type="password"
placeholder="<?php echo esc_attr(str_repeat("*", strlen($privateKeyPwd))); ?>"
autocomplete="off"
value=""
data-parsley-errors-container="#sftp_private_key_password2_error_container"
data-parsley-trigger="change"
data-parsley-equalto="#sftp_private_key_password"
data-parsley-equalto-message="<?php esc_html_e("Passwords do not match", 'duplicator-pro'); ?>"
><br/>
<div id="sftp_private_key_password2_error_container" class="duplicator-error-container"></div>
</td>
</tr>
<tr>
<td class="dpro-sub-title" colspan="2"><b><?php esc_html_e("Settings", 'duplicator-pro'); ?></b></td>
</tr>
<tr>
<th scope="row"><label for="_sftp_storage_folder"><?php esc_html_e("Storage Folder", 'duplicator-pro'); ?></label></th>
<td>
<input id="_sftp_storage_folder" name="_sftp_storage_folder" type="text" value="<?php echo esc_attr($storageFolder); ?>">
<p>
<i>
<?php
printf(
esc_html_x(
'Folder where packages will be stored. This should be %1$san absolute path, not a relative path%2$s
and be unique for each web-site using Duplicator.',
'%1$s representes the opening and %2$s the closing bold (<b>) tag',
'duplicator-pro'
),
'<b>',
'</b>'
);
?>
</i>
</p>
</td>
</tr>
<tr>
<th scope="row"><label for="sftp_max_files"><?php esc_html_e("Max Packages", 'duplicator-pro'); ?></label></th>
<td>
<label for="sftp_max_files">
<input id="sftp_max_files" name="sftp_max_files" data-parsley-errors-container="#sftp_max_files_error_container"
type="text" value="<?php echo (int) $maxPackages; ?>">
<?php esc_html_e("Number of packages to keep in folder.", 'duplicator-pro'); ?> <br/>
<i><?php esc_html_e("When this limit is exceeded, the oldest package will be deleted. Set to 0 for no limit.", 'duplicator-pro'); ?></i>
</label>
<div id="sftp_max_files_error_container" class="duplicator-error-container"></div>
</td>
</tr>
<tr>
<th scope="row"><label for="sftp_timeout_in_secs"><?php esc_html_e("Timeout", 'duplicator-pro'); ?></label></th>
<td>
<label for="sftp_timeout_in_secs">
<input
id="sftp_timeout"
name="sftp_timeout_in_secs"
data-parsley-errors-container="#sftp_timeout_error_container"
type="text"
value="<?php echo (int) $timeout; ?>"
>
<label for="sftp_timeout_in_secs">
<?php esc_html_e("seconds", 'duplicator-pro'); ?>
</label>
<br>
<i>
<?php
esc_html_e(
"Do not modify this setting unless you know the expected result or have talked to support.",
'duplicator-pro'
); ?>
</i>
</label>
<div id="sftp_timeout_error_container" class="duplicator-error-container"></div>
</td>
</tr>
<?php $tplMng->render('admin_pages/storages/parts/provider_foot'); ?>
<script>
jQuery(document).ready(function ($) {
DuplicatorReadPrivateKey = function (file_obj)
{
var files = file_obj.files;
var private_key = files[0];
var reader = new FileReader();
reader.onload = function (e) {
$("#sftp_private_key").val(e.target.result);
}
reader.readAsText(private_key);
}
});
</script>

110
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/gdriveaddon/GDriveAddon.php Normal file
View File

@@ -0,0 +1,110 @@
<?php
/**
* Google Drive ADDON
*
* Name: Google Drive ADDON
* Version: 1
* Author: Duplicator
* Author URI: https://duplicator.com/
*
* PHP version 5.6
*
* @category Duplicator
* @package Plugin
* @author Duplicator
* @copyright 2011-2021 Snapcreek LLC
* @license https://www.gnu.org/licenses/gpl-3.0.html GPLv3
* @version GIT: $Id$
* @link https://duplicator.com/
*/
namespace Duplicator\Addons\GDriveAddon;
use Duplicator\Addons\GDriveAddon\Models\GDriveStorage;
use Duplicator\Addons\GDriveAddon\Utils\Autoloader;
use Duplicator\Core\Addons\AbstractAddonCore;
use Duplicator\Models\Storages\AbstractStorageEntity;
class GDriveAddon extends AbstractAddonCore
{
const ADDON_PATH = __DIR__;
/**
* @return void
*/
public function init()
{
Autoloader::register();
add_action('duplicator_pro_register_storage_types', [$this, 'registerStorages']);
add_filter('duplicator_template_file', array(__CLASS__, 'getTemplateFile'), 10, 2);
add_filter('duplicator_usage_stats_storages_infos', array(__CLASS__, 'getStorageUsageStats'), 10);
}
/**
* @return void
*/
public function registerStorages()
{
GDriveStorage::registerType();
}
/**
* Return template file path
*
* @param string $path path to the template file
* @param string $slugTpl slug of the template
*
* @return string
*/
public static function getTemplateFile($path, $slugTpl)
{
if (strpos($slugTpl, 'gdriveaddon/') === 0) {
return self::getAddonPath() . '/template/' . $slugTpl . '.php';
}
return $path;
}
/**
* Get storage usage stats
*
* @param array<string,int> $storageNums Storages num
*
* @return array<string,int>
*/
public static function getStorageUsageStats($storageNums)
{
if (($storages = AbstractStorageEntity::getAll()) === false) {
$storages = [];
}
$storageNums['storages_gdrive_count'] = 0;
foreach ($storages as $index => $storage) {
if ($storage->getSType() === GDriveStorage::getSType()) {
$storageNums['storages_gdrive_count']++;
}
}
return $storageNums;
}
/**
*
* @return string
*/
public static function getAddonPath()
{
return __DIR__;
}
/**
*
* @return string
*/
public static function getAddonFile()
{
return __FILE__;
}
}

903
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/gdriveaddon/src/Models/GDriveAdapter.php Normal file
View File

@@ -0,0 +1,903 @@
<?php
/**
*
* @package Duplicator
* @copyright (c) 2022, Snap Creek LLC
*/
namespace Duplicator\Addons\GDriveAddon\Models;
use Duplicator\Addons\GDriveAddon\Utils\GoogleClient;
use Duplicator\Models\Storages\AbstractStorageAdapter;
use Duplicator\Utils\OAuth\TokenEntity;
use Exception;
use VendorDuplicator\Psr\Http\Message\RequestInterface;
use VendorDuplicator\Google\Client;
use VendorDuplicator\Google\Http\MediaFileUpload;
use VendorDuplicator\Google\Service\Drive;
use VendorDuplicator\GuzzleHttp\Psr7\Request;
use VendorDuplicator\GuzzleHttp\Psr7\Response;
/**
* @method GDriveStoragePathInfo getPathInfo(string $path)
*/
class GDriveAdapter extends AbstractStorageAdapter
{
const FOLDER_MIME_TYPE = 'application/vnd.google-apps.folder';
const CHUNK_SIZE_STEP = 256 * KB_IN_BYTES;
/** @var Drive The Google Drive service */
protected $drive = null;
/** @var string The root storage path */
protected $storagePath = '';
/** @var string The root storage path id */
protected $storagePathId = '';
/** @var TokenEntity The OAuth token entity */
protected $token = null;
/** @var int */
protected $startTime = 0;
/** @var bool */
protected $sslVerify = true;
/** @var string If empty use server cert else use custom cert path */
protected $sslCert = '';
/** @var bool */
protected $ipv4Only = false;
/**
* Class constructor.
*
* @param TokenEntity $token The OAuth token entity.
* @param string $storagePath The root storage path.
* @param string $storagePathId The root storage path id.
* @param bool $sslVerify If true, use SSL
* @param string $sslCert If empty use server cert
* @param bool $ipv4Only If true, use IPv4 only
*/
public function __construct(
TokenEntity $token,
$storagePath,
$storagePathId = '',
$sslVerify = true,
$sslCert = '',
$ipv4Only = false
) {
$this->token = $token;
$this->storagePath = $storagePath;
$this->storagePathId = $storagePathId;
$this->sslVerify = $sslVerify;
$this->sslCert = $sslCert;
$this->ipv4Only = $ipv4Only;
if ($token->isAboutToExpire()) {
$token->refresh(true);
}
$httpOptions = [];
if ($this->sslVerify === false) {
$verify = false;
} elseif (strlen($this->sslCert) === 0) {
$verify = true;
} else {
$verify = $this->sslCert;
}
$httpOptions['verify'] = $verify;
if ($this->ipv4Only) {
$httpOptions['force_ip_resolve'] = 'v4';
}
$client = new GoogleClient();
$client->setHttpClientOptions($httpOptions);
$client->setAccessToken([
'created' => $token->getCreated(),
'access_token' => $token->getAccessToken(),
'refresh_token' => $token->getRefreshToken(),
'expires_in' => $token->getExpiresIn(),
'scope' => $token->getScope(),
]);
$this->drive = new Drive($client);
}
/**
* Get the Google Drive service.
*
* @return Drive
*/
public function getService()
{
return $this->drive;
}
/**
* Initialize the storage on creation.
*
* @param string $errorMsg The error message if storage is invalid.
*
* @return bool true on success or false on failure.
*/
public function initialize(&$errorMsg = '')
{
if (! $this->token->isValid()) {
$errorMsg = __('Invalid token supplied for google drive', 'duplicator-pro');
return false;
}
if (! $this->exists('/') && ! $this->createDir('/')) {
$errorMsg = __('Unable to create root directory on google drive', 'duplicator-pro');
return false;
}
if (empty($this->storagePathId)) {
$storage = $this->getPathInfo('/');
if ($storage->exists) {
$this->storagePathId = $storage->id;
} else {
$errorMsg = __('Unable to fetch root directory info from Google Drive', 'duplicator-pro');
return false;
}
}
return true;
}
/**
* Destroy the storage on deletion.
*
* @return bool true on success or false on failure.
*/
public function destroy()
{
$this->storagePathId = '';
return $this->delete('/', true);
}
/**
* Check if storage is valid and ready to use.
*
* @param string $errorMsg The error message if storage is invalid.
*
* @return bool
*/
public function isValid(&$errorMsg = '')
{
if (! $this->token->isValid()) {
$errorMsg = 'Invalid token supplied for google drive';
return false;
}
$root = $this->getPathInfo('/');
if (! $root || !$root->exists) {
$errorMsg = 'Root directory does not exist on google drive, false for isValid';
return false;
}
return true;
}
/**
* Create the directory specified by pathname, recursively if necessary.
*
* @param string $path The directory path.
*
* @return bool true on success or false on failure.
*/
protected function realCreateDir($path)
{
$path = trim($path, '/');
if (empty($this->storagePathId)) {
// if we don't have the storage path id set, we fetch it
$storageFolder = $this->getPathInfo('/');
if ($storageFolder->exists) {
$this->storagePathId = $storageFolder->id;
} else {
$path = $this->storagePath . '/' . $path;
}
}
$parts = array_filter(explode('/', $path));
$parent = $this->storagePathId;
// At this point, if we don't have a parent, we need to create from the root path.
// We assume that a partial path may exist
// So we try to search for the path and create it if it doesn't exist
// But once we create one directory, we assume that the rest of the path doesn't exist
// This saves us a lot of calls to the Google Drive API
$pathMayExist = true;
foreach ($parts as $part) {
$query = "name = '{$part}' and trashed = false and mimeType = '" . self::FOLDER_MIME_TYPE . "'";
if ($parent) {
$query .= " and '{$parent}' in parents";
}
if ($pathMayExist) {
// At first, we try to find the directory
$response = $this->drive->files->listFiles([
'q' => $query,
'fields' => 'files(id)',
]);
if ($response->count() > 0) {
$file = $response->getFiles()[0];
$parent = $file->getId();
continue;
}
}
$pathMayExist = false;
// If we didn't find the directory, we create it
$file = new Drive\DriveFile([
'name' => $part,
'mimeType' => self::FOLDER_MIME_TYPE,
]);
if (! empty($parent)) {
$file->setParents([$parent]);
}
try {
$file = $this->drive->files->create($file, ['fields' => 'id']);
} catch (\Exception $e) {
\DUP_PRO_Log::traceObject('[GDriveAdapter] Unable to create directory: ' . $e->getMessage(), $e);
return false;
}
$parent = $file->getId();
}
return true;
}
/**
* Create file with content.
*
* @param string $path The path to file.
* @param string $content The content of file.
*
* @return false|int The number of bytes that were written to the file, or false on failure.
*/
protected function realCreateFile($path, $content)
{
$response = $this->createNewFile($path, [
'data' => $content,
'uploadType' => 'multipart',
'fields' => 'id,size',
]);
if (!$response) {
return false;
}
return (int) $response->getSize();
}
/**
* Delete relative path from storage root.
*
* @param string $path The path to delete. (Accepts directories and files)
* @param bool $recursive Allows the deletion of nested directories specified in the pathname. Default to false.
*
* @return bool true on success or false on failure.
*/
protected function realDelete($path, $recursive = false)
{
$info = $this->getPathInfo($path);
if (! $info->exists) {
return true; // if the path doesn't exist, we can consider it deleted
}
if ($info->isDir && ! $recursive && ! $this->isDirEmpty($path)) {
return false; // if it's a directory and, we are not deleting recursively, we can't delete it
}
try {
$this->drive->files->delete($info->id);
} catch (\Exception $e) {
return false;
}
return true;
}
/**
* Get file content.
*
* @param string $path The path to file.
*
* @return string|false The content of file or false on failure.
*/
public function getFileContent($path)
{
$info = $this->getPathInfo($path);
if (! $info->exists) {
return false;
}
try {
/** @var Response $response */
$response = $this->drive->files->get($info->id, [
'alt' => 'media',
'acknowledgeAbuse' => true,
]);
return $response->getBody()->getContents();
} catch (\Exception $e) {
return false;
}
}
/**
* Move and/or rename a file or directory.
*
* @param string $oldPath Relative storage path
* @param string $newPath Relative storage path
*
* @return bool true on success or false on failure.
*/
protected function realMove($oldPath, $newPath)
{
$fileInfo = $this->getPathInfo($oldPath);
$oldDirInfo = $this->getPathInfo(dirname($oldPath));
$newDirInfo = $this->getPathInfo(dirname($newPath));
$file = $fileInfo->file;
try {
$this->drive->files->update($fileInfo->id, $file, [
'addParents' => $newDirInfo->id,
'removeParents' => $oldDirInfo->id,
]);
} catch (\Exception $e) {
return false;
}
return true;
}
/**
* Get path info and cache it, is path not exists return path info with exists property set to false.
*
* @param string $path Relative storage path, if empty, return root path info.
*
* @return GDriveStoragePathInfo|false The path info or false on error.
*/
protected function getRealPathInfo($path)
{
try {
$info = $this->nestedPathInfo($path);
} catch (\Exception $e) {
$info = false;
}
return $this->buildPathInfo($info);
}
/**
* Get the list of files and directories inside the specified path.
*
* @param string $path Relative storage path, if empty, scan root path.
* @param bool $files If true, add files to the list. Default to true.
* @param bool $folders If true, add folders to the list. Default to true.
*
* @return string[] The list of files and directories, empty array if path is invalid.
*/
public function scanDir($path, $files = true, $folders = true)
{
$info = $this->getPathInfo($path);
if (! $info->exists) {
return [];
}
$query = "'{$info->id}' in parents and trashed = false";
if (! $files) {
$query .= " and mimeType = '" . self::FOLDER_MIME_TYPE . "'";
}
if (! $folders) {
$query .= " and mimeType != '" . self::FOLDER_MIME_TYPE . "'";
}
$nextPageToken = null;
$result = [];
do {
$response = $this->drive->files->listFiles([
'q' => $query,
'pageToken' => $nextPageToken,
]);
$result = array_merge($result, array_map(function ($file) {
$info = $this->buildPathInfo($file);
return $info->path;
}, $response->getFiles()));
} while ($nextPageToken = $response->getNextPageToken());
return $result;
}
/**
* Check if directory is empty.
*
* @param string $path The folder path
* @param string[] $filters Filters to exclude files and folders from the check, if start and end with /, use regex.
*
* @return bool True is ok, false otherwise
*/
public function isDirEmpty($path, $filters = [])
{
$regexFilters = $normalFilters = [];
foreach ($filters as $filter) {
if ($filter[0] === '/' && substr($filter, -1) === '/') {
$regexFilters[] = $filter; // It's a regex filter as it starts and ends with a slash
} else {
$normalFilters[] = $filter;
}
}
$contents = $this->scanDir($path);
foreach ($contents as $item) {
if (in_array($item, $normalFilters)) {
continue;
}
foreach ($regexFilters as $regexFilter) {
if (preg_match($regexFilter, $item) === 1) {
continue 2;
}
}
return false;
}
return true;
}
/**
* Copy local file to storage, partial copy is supported.
* If destination file exists, it will be overwritten.
* If offset is less than the destination file size, the file will be truncated.
*
* @param string $sourceFile The source file full path
* @param string $storageFile Storage destination path
* @param int<0,max> $offset The offset where the data starts.
* @param int $length The maximum number of bytes read. Default to -1 (read all the remaining buffer).
* @param int $timeout The timeout for the copy operation in microseconds. Default to 0 (no timeout).
* @param array<string,mixed> $extraData Extra data to pass to copy function and updated during copy.
* Used for storages that need to maintain persistent data during copy intra-session.
*
* @return false|int The number of bytes that were written to the file, or false on failure.
*/
protected function realCopyToStorage($sourceFile, $storageFile, $offset = 0, $length = -1, $timeout = 0, &$extraData = [])
{
$this->startTrackingTime();
$chunkSize = max(self::CHUNK_SIZE_STEP, floor($length / self::CHUNK_SIZE_STEP) * self::CHUNK_SIZE_STEP);
$source = fopen($sourceFile, 'rb');
if (! $source) {
\DUP_PRO_Log::info(sprintf('[GDriveAdapter] Unable to open source file %s', $sourceFile));
return false;
}
fseek($source, $offset);
$storageFile = '/' . trim($storageFile, '/');
$targetPath = dirname($storageFile);
if ($targetPath === '/' && ! empty($this->storagePathId)) {
$target = new Drive\DriveFile();
$target->setId($this->storagePathId);
} else {
$target = $this->getPathInfo($targetPath);
if (! $target->exists) {
$this->createDir($targetPath);
$target = $this->getPathInfo($targetPath);
}
}
if (! $target) {
\DUP_PRO_Log::info(sprintf('[GDriveAdapter] Unable to get target path info for %s', $targetPath));
return false;
}
$client = $this->drive->getClient();
$client->setDefer(true);
$originalHttpClient = $client->getHttpClient();
$file = new Drive\DriveFile([
'name' => basename($storageFile),
'parents' => [$target->id],
]);
// The file create call returns the request object as we have set client defer to true
/** @var Request $request */
$request = $this->drive->files->create($file);
$media = new MediaFileUpload(
$client,
$request,
'application/octet-stream',
'',
true,
$chunkSize
);
$firstChunk = true;
$media->setFileSize($filesize = filesize($sourceFile));
if (! empty($extraData['resume_uri'])) {
$resumeUri = $extraData['resume_uri'];
try {
$this->forceSet($media, 'progress', $offset);
$this->forceSet($media, 'resumeUri', $resumeUri);
} catch (\Exception $e) {
$client->setHttpClient($originalHttpClient);
\DUP_PRO_Log::info('[GDriveAdapter] Unable to set resume uri: ' . $e->getMessage());
return false;
}
$firstChunk = false;
\DUP_PRO_Log::trace(sprintf('[GDriveAdapter] Resuming upload for %s from offset %s timeout %d', $sourceFile, $offset, $timeout));
}
do {
if ($timeout > 0) {
// Set the timeout for the client (in seconds)
$client->setHttpClient(new \VendorDuplicator\GuzzleHttp\Client([
'base_uri' => $originalHttpClient->getConfig('base_uri'),
'http_errors' => false,
'timeout' => $timeout / SECONDS_IN_MICROSECONDS, // convert microseconds to seconds
]));
}
$chunk = fread($source, $chunkSize);
if (! $chunk) {
\DUP_PRO_Log::trace(sprintf('[GDriveAdapter] Unable to read chunk from %s', $sourceFile));
$status = true; // we can't set it to false, because drive sdk returns false when chunk upload is successful.
break;
}
$status = $media->nextChunk($chunk);
if ($firstChunk) {
\DUP_PRO_Log::trace(sprintf('[GDriveAdapter] Created resume uri for %s and it\'s %s', $sourceFile, $media->getResumeUri()));
$extraData['resume_uri'] = $media->getResumeUri(); // we need to cache the resume uri for the next chunk
$firstChunk = false;
}
$message = '[GDriveAdapter] Uploaded %d/%d bytes, requested [%d, %d] of %s';
\DUP_PRO_Log::trace(sprintf($message, $media->getProgress(), $filesize, $offset, $length, $sourceFile));
if ($length > 0) {
// if we have a length, we need to stop when we reach it
break;
}
} while (!feof($source) && ! $status && ! $this->hasReachedTimeout($timeout));
if (feof($source)) {
// if we reached the end of the file, we can delete the cached resume uri
unset($extraData['resume_uri']);
\DUP_PRO_Log::trace(sprintf('[GDriveAdapter] File %s copied successfully to %s', $sourceFile, $storageFile));
}
$client->setDefer(false);
$client->setHttpClient($originalHttpClient);
// If we have false as status, it means the upload is not finished yet
// On the final chunk upload, we get the file info
if ($status === false || ($status instanceof Drive\DriveFile)) {
return $length > 0 ? $length : $filesize;
}
return false;
}
/**
* Generate info on create dir, this method is exendable by child classes if StoragePathInfo is extended.
*
* @param string $path Dir path
*
* @return GDriveStoragePathInfo
*/
protected function generateCreateDirInfo($path)
{
return $this->getRealPathInfo($path);
}
/**
* Start tracking the time for the current operation
*
* @return void
*/
protected function startTrackingTime()
{
$this->startTime = (int) (microtime(true) * 1000000);
}
/**
* Get the elapsed time since the start of the current operation
*
* @return int
*/
protected function getElapsedTime()
{
return (int) (microtime(true) * 1000000) - $this->startTime;
}
/**
* Check if the operation has reached the timeout
*
* @param int $timeout The timeout in microseconds
*
* @return bool
*/
protected function hasReachedTimeout($timeout)
{
return $timeout > 0 && $this->getElapsedTime() >= ($timeout - 1000000);
}
/**
* Generate info on delete item, this methos is exendable by child classes if StoragePathInfo is extended.
*
* @param string $path Item path
*
* @return GDriveStoragePathInfo
*/
protected function generateDeleteInfo($path)
{
$info = new GDriveStoragePathInfo();
$info->path = $path;
$info->exists = false;
$info->isDir = false;
$info->size = 0;
$info->created = 0;
$info->modified = 0;
return $info;
}
/**
* Create a new file in the specified path.
*
* @param string $path The path to create the file in
* @param array<string, string> $options The options to create the file with
*
* @return false|Drive\DriveFile
*/
protected function createNewFile($path, $options = [])
{
$path = '/' . trim($path, '/');
$parent = $this->getPathInfo(dirname($path));
if (! $parent->exists) {
if ($this->createDir(dirname($path))) {
$parent = $this->getPathInfo(dirname($path));
} else {
return false;
}
}
$file = new Drive\DriveFile([
'name' => basename($path),
'parents' => [$parent->id],
]);
try {
return $this->drive->files->create($file, $options);
} catch (\Exception $e) {
return false;
}
}
/**
* Traverse the path folder by folder and fetch the file info.
*
* @param string $path The path get information for
* @param ?string $parent The parent folder id
*
* @return false|Drive\DriveFile
*/
protected function nestedPathInfo($path, $parent = null)
{
$path = trim($path, '/');
$traversed = explode('/', $this->storagePath); // keep track of the traversed path, by default the root folder is traversed
if (! $parent) {
$parent = $this->storagePathId;
}
if (! $parent) {
// if we don't have a parent, we need to traverse from the root folder
$path = $this->storagePath . '/' . $path;
$traversed = []; // we are traversing from the root folder, so we reset the traversed path
$info = false;
} else {
$info = $this->drive->files->get($parent, ['fields' => 'id,name,mimeType,size,createdTime,modifiedTime,md5Checksum,webViewLink']);
}
$parts = array_filter(explode('/', $path));
foreach ($parts as $index => $part) {
$query = "name = '{$part}' and trashed = false";
if ($parent) {
$query .= " and '{$parent}' in parents";
}
if ($index < count($parts) - 1) {
// if we are not in the last iteration, it's most definitely a folder
$query .= " and mimeType = '" . self::FOLDER_MIME_TYPE . "'";
}
$result = $this->drive->files->listFiles([
'q' => $query,
'fields' => 'files(id,name,mimeType,size,createdTime,modifiedTime,md5Checksum,webViewLink)',
]);
$traversed[] = $part;
if ($result->count() === 0) {
// if we didn't find anything, we can stop here
return false;
}
foreach ($result->getFiles() as $file) {
if ($file->getName() !== $part) {
continue; // we are looking for a file/folder with the same name
}
if ($index < (count($parts) - 1) && $file->getMimeType() !== self::FOLDER_MIME_TYPE) {
// if we are not in the last iteration, we are most definitely looking for a folder, so we skip if it's not
continue;
}
// At this point we have found the file or folder we were looking for
$props = $file->getProperties();
$props['path'] = implode('/', $traversed);
$file->setProperties($props); // add the path to the file properties
$parent = $file->getId();
$info = $file;
// we need to keep looking for the next part
continue 2;
}
// if we got here, we didn't find the file or folder we were looking for
$info = false;
break;
}
return $info;
}
/**
* Build the path info object from Google Drive's file info.
*
* @param Drive\DriveFile|false $file The file info
*
* @return GDriveStoragePathInfo
*/
protected function buildPathInfo($file)
{
$info = new GDriveStoragePathInfo();
if (! $file) {
$info->exists = false;
return $info;
}
$props = $file->getProperties();
$info->exists = true;
$info->id = $file->getId();
$info->name = $file->getName();
$info->mimeType = $file->getMimeType();
$info->isDir = $info->mimeType === self::FOLDER_MIME_TYPE;
$info->size = (int) $file->getSize();
$info->webUrl = $file->getWebViewLink();
$info->created = $file->getCreatedTime() ? strtotime($file->getCreatedTime()) : time();
$info->modified = $file->getModifiedTime() ? strtotime($file->getModifiedTime()) : time();
$info->md5Checksum = $file->getMd5Checksum();
if (isset($props['path'])) {
// if we have the path in the properties, that's a path from the storage folder
// so we remove the storage folder and the slash after that from the path
$info->path = substr($props['path'], strlen($this->storagePath) + 1);
} else {
// if we don't have the path in the properties, we "assume" it's under the storage folder
$info->path = $file->getName();
}
$info->file = $file;
return $info;
}
/**
* Forcefully set a property on an object
*
* @param object $object The object to set the property on
* @param string $property The property to set
* @param mixed $value The value to set
*
* @return void
*/
protected function forceSet($object, $property, $value)
{
if (!is_object($object)) {
throw new Exception('Object must be an object');
}
if (!property_exists($object, $property)) {
throw new Exception('Property ' . $property . ' does not exist on object ' . get_class($object));
}
$reflection = new \ReflectionProperty($object, $property);
$reflection->setAccessible(true);
$reflection->setValue($object, $value);
}
/**
* Copy storage file to local file, partial copy is supported.
* If destination file exists, it will be overwritten.
* If offset is less than the destination file size, the file will be truncated.
*
* @param string $storageFile The storage file path
* @param string $destFile The destination local file full path
* @param int<0,max> $offset The offset where the data starts.
* @param int $length The maximum number of bytes read. Default to -1 (read all the remaining buffer).
* @param int $timeout The timeout for the copy operation in microseconds. Default to 0 (no timeout).
* @param array<string,mixed> $extraData Extra data to pass to copy function and updated during copy.
* Used for storages that need to maintain persistent data during copy intra-session.
*
* @return false|int The number of bytes that were written to the file, or false on failure.
*/
public function copyFromStorage($storageFile, $destFile, $offset = 0, $length = -1, $timeout = 0, &$extraData = [])
{
$client = $this->drive->getClient();
$originalHttpClient = $client->getHttpClient();
if ($timeout > 0) {
$baseUri = $originalHttpClient->getConfig('base_uri');
$client->setHttpClient(new \VendorDuplicator\GuzzleHttp\Client([
'base_uri' => $baseUri,
'http_errors' => \false,
'timeout' => $timeout / 1000000, // convert microseconds to seconds
]));
}
if ($offset == 0 && $length < 0) {
// If we are copying the entire file, we can use the export link
$contents = $this->getFileContent($storageFile);
if ($contents === false) {
$client->setHttpClient($originalHttpClient);
return false;
}
// This may return 0 if the file is empty, so we specifically check for false
return file_put_contents($destFile, $contents);
}
if (! isset($extraData['fileId'])) {
// this is the first chunk, we need to get the file id & make sure the destination is writable & empty.
if (file_put_contents($destFile, '') === false) {
\DUP_PRO_Log::trace('[GDriveAdapter] Unable to write to destination file: ' . $destFile);
$client->setHttpClient($originalHttpClient);
return false;
}
if (! $this->exists($storageFile)) {
$client->setHttpClient($originalHttpClient);
return false;
}
$extraData['fileId'] = $this->getPathInfo($storageFile)->id;
}
$fileId = $extraData['fileId'];
try {
$client->setDefer(true);
/** @var RequestInterface $request */
$request = $this->drive->files->get($fileId, [
'alt' => 'media',
'acknowledgeAbuse' => true,
]);
$client->setDefer(false);
$request = $request->withHeader('Range', 'bytes=' . $offset . '-' . ($length > 0 ? ($offset + $length - 1) : ''));
$response = $client->execute($request, null);
$contents = $response->getBody()->getContents();
$client->setHttpClient($originalHttpClient);
if (file_put_contents($destFile, $contents, FILE_APPEND) !== false) {
return $length;
}
return false;
} catch (\Exception $e) {
$client->setHttpClient($originalHttpClient);
\DUP_PRO_Log::trace('[GDriveAdapter] Unable to get file content: ' . $e->getMessage());
return false;
}
}
}

617
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/gdriveaddon/src/Models/GDriveStorage.php Normal file
View File

@@ -0,0 +1,617 @@
<?php
/**
*
* @package Duplicator
* @copyright (c) 2022, Snap Creek LLC
*/
namespace Duplicator\Addons\GDriveAddon\Models;
use DUP_PRO_Global_Entity;
use DUP_PRO_Google_Drive_Transfer_Mode;
use DUP_PRO_Log;
use DUP_PRO_Package_Upload_Info;
use DUP_PRO_Server;
use Duplicator\Core\Views\TplMng;
use Duplicator\Libs\Snap\SnapUtil;
use Duplicator\Models\DynamicGlobalEntity;
use Duplicator\Models\Storages\AbstractStorageEntity;
use Duplicator\Models\Storages\StorageAuthInterface;
use Duplicator\Utils\OAuth\TokenEntity;
use Duplicator\Utils\OAuth\TokenService;
use Exception;
/**
* @property GDriveAdapter $adapter
*/
class GDriveStorage extends AbstractStorageEntity implements StorageAuthInterface
{
// These numbers represent clients created in Google Cloud Console
const GDRIVE_CLIENT_NATIVE = 1; // Native client 1
const GDRIVE_CLIENT_WEB0722 = 2; // Web client 07/2022
const GDRIVE_CLIENT_LATEST = 2; // Latest out of these above
const REQUIRED_SCOPES = [
"openid",
"https://www.googleapis.com/auth/userinfo.profile",
"https://www.googleapis.com/auth/userinfo.email",
// The drive.file scope limits access to just those files created by the plugin
"https://www.googleapis.com/auth/drive.file",
];
/**
* Get default config
*
* @return array<string,scalar>
*/
protected static function getDefaultConfig()
{
$config = parent::getDefaultConfig();
$config = array_merge(
$config,
[
'storage_folder_id' => '',
'storage_folder_web_url' => '',
'token_json' => '',
'refresh_token' => '',
'client_number' => -1,
'authorized' => false,
]
);
return $config;
}
/**
* Serialize
*
* Wakeup method.
*
* @return void
*/
public function __wakeup()
{
parent::__wakeup();
if ($this->legacyEntity) {
// Old storage entity
$this->legacyEntity = false;
// Make sure the storage type is right from the old entity
$this->storage_type = $this->getSType();
$this->config = [
'token_json' => $this->gdrive_access_token_set_json,
'refresh_token' => $this->gdrive_refresh_token,
'storage_folder' => ltrim($this->gdrive_storage_folder, '/\\'),
'client_number' => $this->gdrive_client_number,
'max_packages' => $this->gdrive_max_files,
'authorized' => ($this->gdrive_authorization_state == 1),
];
// reset old values
$this->gdrive_access_token_set_json = '';
$this->gdrive_refresh_token = '';
$this->gdrive_storage_folder = '';
$this->gdrive_client_number = -1;
$this->gdrive_max_files = 10;
$this->gdrive_authorization_state = 0;
}
}
/**
* Return the storage type
*
* @return int
*/
public static function getSType()
{
return 3;
}
/**
* Returns the storage type icon.
*
* @return string Returns the storage icon
*/
public static function getStypeIcon()
{
$imgUrl = DUPLICATOR_PRO_IMG_URL . '/google-drive.svg';
return '<img src="' . esc_url($imgUrl) . '" class="dup-storage-icon" alt="' . esc_attr(static::getStypeName()) . '" />';
}
/**
* Returns the storage type name.
*
* @return string
*/
public static function getStypeName()
{
return __('Google Drive', 'duplicator-pro');
}
/**
* Get storage location string
*
* @return string
*/
public function getLocationString()
{
if ($this->isAuthorized()) {
return $this->config['storage_folder_web_url'];
} else {
return __('Not Authenticated', 'duplicator-pro');
}
}
/**
* Check if storage is supported
*
* @return bool
*/
public static function isSupported()
{
return (SnapUtil::isCurlEnabled() || SnapUtil::isUrlFopenEnabled());
}
/**
* Get supported notice, displayed if storage isn't supported
*
* @return string html string or empty if storage is supported
*/
public static function getNotSupportedNotice()
{
if (static::isSupported()) {
return '';
}
if (!SnapUtil::isCurlEnabled() && !SnapUtil::isUrlFopenEnabled()) {
return esc_html__(
'Google Drive requires either the PHP CURL extension enabled or the allow_url_fopen runtime configuration to be enabled.',
'duplicator-pro'
);
} elseif (!SnapUtil::isCurlEnabled()) {
return esc_html__('Google Drive requires the PHP CURL extension enabled.', 'duplicator-pro');
} else {
return esc_html__('Google Drive requires the allow_url_fopen runtime configuration to be enabled.', 'duplicator-pro');
}
}
/**
* Get upload chunk size in bytes
*
* @return int bytes
*/
public function getUploadChunkSize()
{
$dGlobal = DynamicGlobalEntity::getInstance();
$chunkSizeKb = $dGlobal->getVal('gdrive_upload_chunksize_in_kb', 256);
return $chunkSizeKb * KB_IN_BYTES;
}
/**
* Get upload chunk timeout in seconds
*
* @return int timeout in microseconds, 0 unlimited
*/
public function getUploadChunkTimeout()
{
// @todo: fixed to 10 seconds for historical reasons, make it configurable.
return 10 * 1000000;
}
/**
* Check if storage is valid
*
* @return bool Return true if storage is valid and ready to use, false otherwise
*/
public function isValid()
{
return $this->isAuthorized();
}
/**
* Is autorized
*
* @return bool
*/
public function isAuthorized()
{
return $this->config['authorized'];
}
/**
* Returns an HTML anchor tag of location
*
* @return string Returns an HTML anchor tag with the storage location as a hyperlink.
*/
public function getHtmlLocationLink()
{
if (! $this->isAuthorized() || empty($this->config['storage_folder_web_url'])) {
return '<span>' . esc_html($this->getStorageFolder()) . '</span>';
}
return sprintf("<a href=\"%s\" target=\"_blank\">%s</a>", esc_url($this->config['storage_folder_web_url']), esc_html($this->getStorageFolder()));
}
/**
* Authorized from HTTP request
*
* @param string $message Message
*
* @return bool True if authorized, false if failed
*/
public function authorizeFromRequest(&$message = '')
{
$tokenPairString = '';
try {
if (($refreshToken = SnapUtil::sanitizeTextInput(SnapUtil::INPUT_REQUEST, 'auth_code')) === '') {
throw new Exception(__('Authorization code is empty', 'duplicator-pro'));
}
$this->name = SnapUtil::sanitizeTextInput(SnapUtil::INPUT_REQUEST, 'name', '');
$this->notes = SnapUtil::sanitizeDefaultInput(SnapUtil::INPUT_REQUEST, 'notes', '');
$this->config['max_packages'] = SnapUtil::sanitizeIntInput(SnapUtil::INPUT_REQUEST, 'max_packages', 10);
$this->config['storage_folder'] = self::getSanitizedInputFolder('storage_folder', 'remove');
$this->revokeAuthorization();
$token = (new TokenEntity(static::getSType(), ['refresh_token' => $refreshToken]));
if (!$token->refresh(true)) {
throw new Exception(__('Failed to fetch information from Google Drive. Make sure the token is valid.', 'duplicator-pro'));
}
if (empty($token->getScope())) {
throw new Exception(__("Couldn't connect. Google Drive scopes not found.", 'duplicator-pro'));
}
if (! $token->hasScopes(static::REQUIRED_SCOPES)) {
throw new Exception(
__(
"Authorization failed. You did not allow all required permissions. Try again and make sure that you checked all checkboxes.",
'duplicator-pro'
)
);
}
$this->config['refresh_token'] = $token->getRefreshToken();
$this->config['token_json'] = wp_json_encode([
'created' => $token->getCreated(),
'access_token' => $token->getAccessToken(),
'refresh_token' => $token->getRefreshToken(),
'expires_in' => $token->getExpiresIn(),
'scope' => $token->getScope(),
]);
$this->config['client_number'] = self::GDRIVE_CLIENT_LATEST;
$this->config['authorized'] = $token->isValid();
} catch (Exception $e) {
DUP_PRO_Log::traceException($e, "Problem authorizing Google Drive access token");
DUP_PRO_Log::traceObject('Token pair string from authorization:', $tokenPairString);
$message = $e->getMessage();
return false;
}
$this->save();
$message = __('Google Drive is connected successfully and Storage Provider Updated.', 'duplicator-pro');
return true;
}
/**
* Revokes authorization
*
* @param string $message Message
*
* @return bool True if authorized, false if failed
*/
public function revokeAuthorization(&$message = '')
{
if (!$this->isAuthorized()) {
$message = __('Google Drive isn\'t authorized.', 'duplicator-pro');
return true;
}
try {
$client = $this->getAdapter()->getService()->getClient();
if (!empty($this->config['refresh_token'])) {
$client->revokeToken($this->config['refresh_token']);
}
$accessTokenObj = json_decode($this->config['token_json']);
if (is_object($accessTokenObj) && property_exists($accessTokenObj, 'access_token')) {
$gdrive_access_token = $accessTokenObj->access_token;
} else {
$gdrive_access_token = false;
}
if (!empty($gdrive_access_token)) {
$client->revokeToken($gdrive_access_token);
}
$this->config['token_json'] = '';
$this->config['refresh_token'] = '';
$this->config['client_number'] = -1;
$this->config['authorized'] = false;
} catch (Exception $e) {
DUP_PRO_Log::trace("Problem revoking Google Drive access token msg: " . $e->getMessage());
$message = $e->getMessage();
return false;
}
$message = __('Google Drive is disconnected successfully.', 'duplicator-pro');
return true;
}
/**
* Get authorization URL
*
* @return string
*/
public function getAuthorizationUrl()
{
return (new TokenService(static::getSType()))->getRedirectUri();
}
/**
* Get storage adapter
*
* @return GDriveAdapter
*/
public function getAdapter()
{
$global = DUP_PRO_Global_Entity::getInstance();
$token = $this->getTokenFromConfig();
if (! $this->adapter) {
if (! isset($this->config['storage_folder_id']) || empty($this->config['storage_folder_id'])) {
$this->adapter = new GDriveAdapter(
$token,
$this->config['storage_folder'],
'',
!$global->ssl_disableverify,
($global->ssl_useservercerts ? '' : DUPLICATOR_PRO_CERT_PATH),
$global->ipv4_only
);
$this->adapter->initialize();
$storageFolder = $this->adapter->getPathInfo('/');
$this->config['storage_folder_id'] = $storageFolder->id;
$this->config['storage_folder_web_url'] = $storageFolder->webUrl;
$this->save();
} else {
$this->adapter = new GDriveAdapter(
$token,
$this->config['storage_folder'],
$this->config['storage_folder_id'],
!$global->ssl_disableverify,
($global->ssl_useservercerts ? '' : DUPLICATOR_PRO_CERT_PATH),
$global->ipv4_only
);
$this->adapter->initialize();
}
}
$storageFolder = $this->adapter->getPathInfo('/');
if ($storageFolder->name !== basename($this->getStorageFolder())) {
// root folder id & storage folder name is different.
$this->adapter = new GDriveAdapter(
$token,
$this->config['storage_folder'],
'',
!$global->ssl_disableverify,
($global->ssl_useservercerts ? '' : DUPLICATOR_PRO_CERT_PATH),
$global->ipv4_only
);
$this->adapter->initialize();
$storageFolder = $this->adapter->getPathInfo('/');
$this->config['storage_folder_id'] = $storageFolder->id;
$this->config['storage_folder_web_url'] = $storageFolder->webUrl;
$this->save();
}
return $this->adapter;
}
/**
* Render form config fields
*
* @param bool $echo Echo or return
*
* @return string
*/
public function renderConfigFields($echo = true)
{
$userInfo = false;
$quotaString = '';
if ($this->isAuthorized()) {
$adapter = $this->getAdapter();
try {
$serviceDrive = $adapter->getService();
$optParams = array('fields' => '*');
$about = $serviceDrive->about->get($optParams);
$storageQuota = $about->getStorageQuota();
$quota_total = max($storageQuota->getLimit(), 1);
$quota_used = $storageQuota->getUsage();
$userInfo = $about->getUser();
if (is_numeric($quota_total) && is_numeric($quota_used)) {
$available_quota = $quota_total - $quota_used;
$used_perc = round($quota_used * 100 / $quota_total, 1);
$quotaString = sprintf(
__('%1$s%% used, %2$s available', 'duplicator-pro'),
$used_perc,
size_format($available_quota)
);
}
} catch (\Exception $e) {
DUP_PRO_Log::info("Problem getting Google Drive user info and quota: " . $e->getMessage());
$userInfo = $quotaString = null;
}
}
return TplMng::getInstance()->render(
'gdriveaddon/configs/google_drive',
[
'storage' => $this,
'storageFolder' => $this->config['storage_folder'],
'maxPackages' => $this->config['max_packages'],
'userInfo' => $userInfo,
'quotaString' => $quotaString,
],
$echo
);
}
/**
* Update data from http request, this method don't save data, just update object properties
*
* @param string $message Message
*
* @return bool True if success and all data is valid, false otherwise
*/
public function updateFromHttpRequest(&$message = '')
{
if ((parent::updateFromHttpRequest($message) === false)) {
return false;
}
$previousStorageFolder = $this->config['storage_folder'];
$this->config['max_packages'] = SnapUtil::sanitizeIntInput(SnapUtil::INPUT_REQUEST, 'gdrive_max_files', 10);
$this->config['storage_folder'] = self::getSanitizedInputFolder('_gdrive_storage_folder', 'remove');
if ($previousStorageFolder !== $this->config['storage_folder']) {
$this->config['storage_folder_id'] = '';
$this->config['storage_folder_web_url'] = '';
}
$message = sprintf(
__('Google Drive Storage Updated.', 'duplicator-pro'),
$this->config['server'],
$this->getStorageFolder()
);
return true;
}
/**
* Get the token entity from config
*
* @return TokenEntity
*/
protected function getTokenFromConfig()
{
$token = new TokenEntity(static::getSType(), $this->config['token_json']);
if ($token->isAboutToExpire()) {
try {
$token->refresh(true);
} catch (Exception $e) {
DUP_PRO_Log::traceException($e, "Problem refreshing Google Drive access token");
}
$this->config['token_json'] = wp_json_encode([
'created' => $token->getCreated(),
'access_token' => $token->getAccessToken(),
'refresh_token' => $token->getRefreshToken(),
'expires_in' => $token->getExpiresIn(),
'scope' => $token->getScope(),
]);
$this->save();
}
return $token;
}
/**
* @return void
*/
public static function registerType()
{
parent::registerType();
add_action('duplicator_update_global_storage_settings', function () {
$dGlobal = DynamicGlobalEntity::getInstance();
foreach (static::getDefaultSettings() as $key => $default) {
$value = SnapUtil::sanitizeIntInput(SnapUtil::INPUT_REQUEST, $key, $default);
$dGlobal->setVal($key, $value);
}
});
}
/**
* Get default settings
*
* @return array<string, scalar>
*/
protected static function getDefaultSettings()
{
return [
'gdrive_upload_chunksize_in_kb' => 1024,
'gdrive_transfer_mode' => DUP_PRO_Google_Drive_Transfer_Mode::Auto,
];
}
/**
* @return void
*/
public static function renderGlobalOptions()
{
$values = static::getDefaultSettings();
$dGlobal = DynamicGlobalEntity::getInstance();
foreach ($values as $key => $default) {
$values[$key] = $dGlobal->getVal($key, $default);
}
?>
<h3 class="title"><?php echo esc_html(static::getStypeName()); ?></h3>
<hr size="1" />
<table class="form-table">
<tr valign="top">
<th scope="row"><label><?php esc_html_e("Upload Chunk Size", 'duplicator-pro'); ?></label></th>
<td>
<input
class="dup-narrow-input text-right"
name="gdrive_upload_chunksize_in_kb"
id="gdrive_upload_chunksize_in_kb"
type="number"
min="256"
step="256"
data-parsley-required
data-parsley-type="number"
data-parsley-errors-container="#gdrive_upload_chunksize_in_kb_error_container"
value="<?php echo (int) $values['gdrive_upload_chunksize_in_kb']; ?>"
>&nbsp;<b>KB</b>
<div id="gdrive_upload_chunksize_in_kb_error_container" class="duplicator-error-container"></div>
<p class="description">
<?php esc_html_e(
'How much should be uploaded to Google Drive per attempt. Higher=faster but less reliable. It should be multiple of 256.',
'duplicator-pro'
); ?>
</p>
</td>
</tr>
<tr valign="top">
<th scope="row"><label><?php esc_html_e("Transfer Mode", 'duplicator-pro'); ?></label></th>
<td>
<input
type="radio"
value="<?php echo (int) DUP_PRO_Google_Drive_Transfer_Mode::Auto ?>"
name="gdrive_transfer_mode" id="gdrive_transfer_mode_auto"
<?php checked($values['gdrive_transfer_mode'], DUP_PRO_Google_Drive_Transfer_Mode::Auto); ?>
>
<label for="gdrive_transfer_mode_auto"><?php esc_html_e("Auto", 'duplicator-pro'); ?></label> &nbsp;
<input
type="radio" <?php disabled(!DUP_PRO_Server::isURLFopenEnabled()) ?>
value="<?php echo (int) DUP_PRO_Google_Drive_Transfer_Mode::FOpen_URL ?>"
name="gdrive_transfer_mode"
id="gdrive_transfer_mode_stream"
<?php checked($values['gdrive_transfer_mode'], DUP_PRO_Google_Drive_Transfer_Mode::FOpen_URL); ?>
>
<label for="gdrive_transfer_mode_stream"><?php esc_html_e("FOpen URL", 'duplicator-pro'); ?></label> &nbsp;
<?php if (!DUP_PRO_Server::isURLFopenEnabled()) : ?>
<i
class="fas fa-question-circle fa-sm"
data-tooltip-title="<?php esc_attr_e("FOpen URL", 'duplicator-pro'); ?>"
data-tooltip="<?php esc_attr_e('Not available because "allow_url_fopen" is turned off in the php.ini', 'duplicator-pro'); ?>">
</i>
<?php endif; ?>
</td>
</tr>
</table>
<?php
}
}

33
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/gdriveaddon/src/Models/GDriveStoragePathInfo.php Normal file
View File

@@ -0,0 +1,33 @@
<?php
/**
*
* @package Duplicator
* @copyright (c) 2022, Snap Creek LLC
*/
namespace Duplicator\Addons\GDriveAddon\Models;
use Duplicator\Models\Storages\StoragePathInfo;
use VendorDuplicator\Google\Service\Drive\DriveFile;
class GDriveStoragePathInfo extends StoragePathInfo
{
/** @var string */
public $id = '';
/** @var string */
public $name = '';
/** @var string */
public $mimeType = '';
/** @var string */
public $webUrl = '';
/** @var string */
public $md5Checksum = '';
/** @var DriveFile */
public $file;
}

71
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/gdriveaddon/src/Utils/Autoloader.php Normal file
View File

@@ -0,0 +1,71 @@
<?php
namespace Duplicator\Addons\GDriveAddon\Utils;
use Duplicator\Addons\GDriveAddon\GDriveAddon;
use Duplicator\Utils\AbstractAutoloader;
class Autoloader extends AbstractAutoloader
{
const VENDOR_PATH = GDriveAddon::ADDON_PATH . '/vendor-prefixed/';
/**
* Register autoloader function
*
* @return void
*/
public static function register()
{
spl_autoload_register([__CLASS__, 'load']);
require_once GDriveAddon::ADDON_PATH . '/vendor-prefixed/guzzlehttp/guzzle/src/functions_include.php';
require_once GDriveAddon::ADDON_PATH . '/vendor-prefixed/guzzlehttp/promises/src/functions_include.php';
require_once GDriveAddon::ADDON_PATH . '/vendor-prefixed/guzzlehttp/psr7/src/functions_include.php';
require_once GDriveAddon::ADDON_PATH . '/vendor-prefixed/ralouphie/getallheaders/src/getallheaders.php';
}
/**
* Load class
*
* @param string $className class name
*
* @return void
*/
public static function load($className)
{
if (strpos($className, self::ROOT_VENDOR) === 0) {
foreach (self::getNamespacesVendorMapping() as $namespace => $mappedPath) {
if (strpos($className, $namespace) !== 0) {
continue;
}
$filepath = self::getFilenameFromClass($className, $namespace, $mappedPath);
if (file_exists($filepath)) {
include $filepath;
return;
}
}
}
}
/**
* Return namespace mapping
*
* @return string[]
*/
protected static function getNamespacesVendorMapping()
{
return [
self::ROOT_VENDOR . 'Firebase\\JWT' => self::VENDOR_PATH . 'firebase/php-jwt/src/',
self::ROOT_VENDOR . 'Google\\Service' => self::VENDOR_PATH . 'google/apiclient-services/src',
self::ROOT_VENDOR . 'Google\\Auth' => self::VENDOR_PATH . 'google/auth/src',
self::ROOT_VENDOR . 'Google' => self::VENDOR_PATH . 'google/apiclient/src',
self::ROOT_VENDOR . 'GuzzleHttp\\Promise' => self::VENDOR_PATH . 'guzzlehttp/promises/src',
self::ROOT_VENDOR . 'GuzzleHttp\\Psr7' => self::VENDOR_PATH . 'guzzlehttp/psr7/src',
self::ROOT_VENDOR . 'GuzzleHttp' => self::VENDOR_PATH . 'guzzlehttp/guzzle/src',
self::ROOT_VENDOR . 'Monolog' => self::VENDOR_PATH . 'monolog/monolog/src/Monolog',
self::ROOT_VENDOR . 'Psr\\Http\\Message' => self::VENDOR_PATH . 'psr/http-message/src',
self::ROOT_VENDOR . 'Psr\\Log' => self::VENDOR_PATH . 'psr/log/Psr/Log',
self::ROOT_VENDOR . 'Psr\\Cache' => self::VENDOR_PATH . 'psr/cache/src',
];
}
}

41
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/gdriveaddon/src/Utils/GoogleClient.php Normal file
View File

@@ -0,0 +1,41 @@
<?php
namespace Duplicator\Addons\GDriveAddon\Utils;
use VendorDuplicator\Google\Client;
use VendorDuplicator\GuzzleHttp\Client as GuzzleClient;
class GoogleClient extends Client
{
/** @var array<string,mixed> */
protected $customHttpOptions = [];
/**
* Set http client options
*
* @param array<string,mixed> $options options
*
* @return void
*/
public function setHttpClientOptions(array $options)
{
$this->customHttpOptions = $options;
}
/**
* Create a new http client.
*
* @return GuzzleClient
*/
protected function createDefaultHttpClient()
{
$options = [
'base_uri' => $this->getConfig('base_path'),
'http_errors' => false,
];
$options = array_merge($options, $this->customHttpOptions);
$guzzleClient = new GuzzleClient($options);
return $guzzleClient;
}
}

263
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/gdriveaddon/template/gdriveaddon/configs/google_drive.php Normal file
View File

@@ -0,0 +1,263 @@
<?php
/**
* Duplicator messages sections
*
* @package Duplicator
* @copyright (c) 2022, Snap Creek LLC
*/
use Duplicator\Addons\GDriveAddon\Models\GDriveStorage;
defined("ABSPATH") or die("");
/**
* Variables
*
* @var \Duplicator\Core\Controllers\ControllersManager $ctrlMng
* @var \Duplicator\Core\Views\TplMng $tplMng
* @var array<string, mixed> $tplData
* @var GDriveStorage $storage
*/
$storage = $tplData["storage"];
/** @var string */
$storageFolder = $tplData["storageFolder"];
/** @var int */
$maxPackages = $tplData["maxPackages"];
/** @var \VendorDuplicator\Google\Service\Drive\User $userInfo */
$userInfo = $tplData["userInfo"];
/** @var string */
$quotaString = $tplData["quotaString"];
$tplMng->render('admin_pages/storages/parts/provider_head');
?>
<tr>
<th scope="row"><label for=""><?php esc_html_e("Authorization", 'duplicator-pro'); ?></label></th>
<td class="gdrive-authorize">
<?php if (!$storage->isAuthorized()) : ?>
<div class='gdrive-authorization-state' id="gdrive-state-unauthorized">
<!-- CONNECT -->
<div id="dpro-gdrive-connect-btn-area">
<button
id="dpro-gdrive-connect-btn"
type="button"
class="button button-large"
onclick="DupPro.Storage.GDrive.GoogleGetAuthUrl();"
>
<i class="fa fa-plug"></i> <?php esc_html_e('Connect to Google Drive', 'duplicator-pro'); ?>
<img
src="<?php echo esc_url(DUPLICATOR_PRO_IMG_URL . '/google-drive.svg'); ?>"
style='vertical-align: middle; margin:-2px 0 0 3px; height:18px; width:18px'
/>
</button>
</div>
<div class="authorization-state" id="dpro-gdrive-connect-progress">
<div style="padding:10px">
<i class="fas fa-circle-notch fa-spin"></i> <?php esc_html_e('Getting Google Drive Request Token...', 'duplicator-pro'); ?>
</div>
</div>
<!-- STEPS -->
<div id="dpro-gdrive-steps">
<div>
<b><?php esc_html_e('Step 1:', 'duplicator-pro'); ?></b>&nbsp;
<?php
esc_html_e(
"Duplicator needs to authorize Google Drive. Make sure to allow all required permissions.",
'duplicator-pro'
); ?>
<div class="auth-code-popup-note">
<?php
echo esc_html__(
'Note: Clicking the button below will open a new tab/window. Please be sure your browser does not block popups.',
'duplicator-pro'
) . ' google_drive.php' .
esc_html__('If a new tab/window does not open check your browsers address bar to allow popups from this URL.', 'duplicator-pro');
?>
</div>
<button id="gdrive-auth-window-button" class="button" onclick="DupPro.Storage.GDrive.OpenAuthPage(); return false;">
<i class="fa fa-user"></i> <?php esc_html_e("Authorize Google Drive", 'duplicator-pro'); ?>
</button>
</div>
<div id="gdrive-auth-code-area">
<b><?php esc_html_e('Step 2:', 'duplicator-pro'); ?></b>
<?php esc_html_e("Paste code from Google authorization page.", 'duplicator-pro'); ?> <br/>
<input style="width:400px" id="gdrive-auth-code" name="gdrive-auth-code" />
</div>
<b><?php esc_html_e('Step 3:', 'duplicator-pro'); ?></b>
<?php esc_html_e('Finalize Google Drive setup by clicking the "Finalize Setup" button.', 'duplicator-pro') ?>
<br/>
<button
id="gdrive-finalize-setup"
type="button"
class="button"
>
<i class="fa fa-check-square"></i> <?php esc_html_e('Finalize Setup', 'duplicator-pro'); ?>
</button>
</div>
</div>
<?php else : ?>
<div class='gdrive-authorization-state' id="gdrive-state-authorized" style="margin-top:-10px">
<?php if ($userInfo != null) : ?>
<h3>
<?php esc_html_e('Google Drive Account', 'duplicator-pro'); ?><br/>
<i class="dpro-edit-info">
<?php esc_html_e('Duplicator has been authorized to access this user\'s Google Drive account', 'duplicator-pro'); ?>
</i>
</h3>
<div id="gdrive-account-info">
<label><?php esc_html_e('Name', 'duplicator-pro'); ?>:</label>
<?php echo esc_html($userInfo->getDisplayName()); ?><br/>
<label><?php esc_html_e('Email', 'duplicator-pro'); ?>:</label> <?php echo esc_html($userInfo->getEmailAddress()); ?>
<?php if (strlen($quotaString) > 0) { ?>
<br>
<label><?php esc_html_e('Quota', 'duplicator-pro'); ?>:</label> <?php echo esc_html($quotaString); ?>
<?php } ?>
</div><br/>
<?php else : ?>
<div><?php esc_html_e('Error retrieving user information.', 'duplicator-pro'); ?></div>
<?php endif ?>
<button
id="dup-gdrive-cancel-authorization"
type="button"
class="button"
>
<?php esc_html_e('Cancel Authorization', 'duplicator-pro'); ?>
</button><br/>
<i class="dpro-edit-info">
<?php
esc_html_e(
'Disassociates storage provider with the Google Drive account. Will require re-authorization.',
'duplicator-pro'
); ?>
</i>
</div>
<?php endif ?>
</td>
</tr>
<tr>
<th scope="row">
<label for="_gdrive_storage_folder">
<?php esc_html_e("Storage Folder", 'duplicator-pro'); ?>
</label>
</th>
<td>
<b>//Google Drive/</b>
<input
id="_gdrive_storage_folder"
name="_gdrive_storage_folder"
type="text"
value="<?php echo esc_attr($storageFolder); ?>"
class="dpro-storeage-folder-path"
>
<p>
<i>
<?php
esc_html_e(
"Folder where packages will be stored. This should be unique for each web-site using Duplicator.",
'duplicator-pro'
); ?>
</i>
<?php
$tipContent = __(
'If the directory path above is already in Google Drive before connecting then a duplicate folder name will be made in the same path.',
'duplicator-pro'
) . ' google_drive.php' . __('This is because the plugin only has rights to folders it creates.', 'duplicator-pro');
?>
<i
class="fas fa-question-circle fa-sm"
data-tooltip-title="<?php esc_attr_e("Storage Folder Notice", 'duplicator-pro'); ?>"
data-tooltip="<?php esc_attr($tipContent); ?>"
>
</i>
</p>
</td>
</tr>
<tr>
<th scope="row"><label for=""><?php esc_html_e("Max Packages", 'duplicator-pro'); ?></label></th>
<td>
<label for="gdrive_max_files">
<input
id="gdrive_max_files"
name="gdrive_max_files"
type="number"
value="<?php echo (int) $maxPackages; ?>"
min="0"
maxlength="4"
data-parsley-errors-container="#gdrive_max_files_error_container"
data-parsley-required="true"
data-parsley-type="number"
data-parsley-min="0"
>&nbsp;
<?php esc_html_e("Number of packages to keep in folder.", 'duplicator-pro'); ?> <br/>
<i><?php esc_html_e("When this limit is exceeded, the oldest package will be deleted. Set to 0 for no limit.", 'duplicator-pro'); ?></i>
</label>
<div id="gdrive_max_files_error_container" class="duplicator-error-container"></div>
</td>
</tr>
<?php
$tplMng->render('admin_pages/storages/parts/provider_foot');
// Alerts for Google Drive
$alertConnStatus = new DUP_PRO_UI_Dialog();
$alertConnStatus->title = __('Google Drive Authorization Error', 'duplicator-pro');
$alertConnStatus->message = ''; // javascript inserted message
$alertConnStatus->initAlert();
?>
<script>
jQuery(document).ready(function ($) {
DupPro.Storage.GDrive = DupPro.Storage.GDrive || {};
$('#dup-gdrive-cancel-authorization').click(function (event) {
event.stopPropagation();
DupPro.Storage.RevokeAuth(<?php echo (int) $storage->getId(); ?>);
});
DupPro.Storage.GDrive.GoogleGetAuthUrl = function ()
{
$('#dpro-gdrive-connect-btn-area').hide();
$('#dpro-gdrive-steps').show();
DupPro.Storage.GDrive.AuthUrl = <?php echo json_encode($storage->getAuthorizationUrl()); ?>;
}
DupPro.Storage.GDrive.OpenAuthPage = function ()
{
window.open(DupPro.Storage.GDrive.AuthUrl, '_blank');
}
$('#gdrive-finalize-setup').click(function (event) {
event.stopPropagation();
if ($('#gdrive-auth-code').val().length > 5) {
DupPro.Storage.PrepareForSubmit();
//$("#dup-storage-form").submit();
DupPro.Storage.Authorize(
<?php echo (int) $storage->getId(); ?>,
<?php echo (int) $storage->getSType(); ?>,
{
'name': $('#name').val(),
'notes': $('#notes').val(),
'storage_folder': $('#_gdrive_storage_folder').val(),
'max_packages': $('#gdrive_max_files').val(),
'auth_code' : $('#gdrive-auth-code').val()
}
);
} else {
<?php $alertConnStatus->showAlert(); ?>
let alertMsg = "<i class='fas fa-exclamation-triangle'></i> " +
"<?php esc_html_e('Please enter your Google Drive authorization code!', 'duplicator-pro'); ?>";
<?php $alertConnStatus->updateMessage("alertMsg"); ?>
}
return false;
});
});
</script>

3
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/index.php Normal file
View File

@@ -0,0 +1,3 @@
<?php
// silent

90
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/onedriveaddon/OneDriveAddon.php Normal file
View File

@@ -0,0 +1,90 @@
<?php
namespace Duplicator\Addons\OneDriveAddon;
use Duplicator\Addons\OneDriveAddon\Models\OneDriveStorage;
use Duplicator\Core\Addons\AbstractAddonCore;
use Duplicator\Models\Storages\AbstractStorageEntity;
class OneDriveAddon extends AbstractAddonCore
{
const ADDON_PATH = __DIR__;
/**
* @return void
*/
public function init()
{
add_action('duplicator_pro_register_storage_types', [$this, 'registerStorages']);
add_filter('duplicator_template_file', array(__CLASS__, 'getTemplateFile'), 10, 2);
add_filter('duplicator_usage_stats_storages_infos', array(__CLASS__, 'getStorageUsageStats'), 10);
}
/**
* Register storages
*
* @return void
*
* @throws \Exception
*/
public function registerStorages()
{
OneDriveStorage::registerType();
}
/**
* Return template file path
*
* @param string $path path to the template file
* @param string $slugTpl slug of the template
*
* @return string
*/
public static function getTemplateFile($path, $slugTpl)
{
if (strpos($slugTpl, 'onedriveaddon/') === 0) {
return self::getAddonPath() . '/template/' . $slugTpl . '.php';
}
return $path;
}
/**
* Get storage usage stats
*
* @param array<string,int> $storageNums Storages num
*
* @return array<string,int>
*/
public static function getStorageUsageStats($storageNums)
{
if (($storages = AbstractStorageEntity::getAll()) === false) {
$storages = [];
}
$storageNums['storages_onedrive_count'] = 0;
foreach ($storages as $storage) {
if ($storage->getSType() === OneDriveStorage::getSType()) {
$storageNums['storages_onedrive_count']++;
}
}
return $storageNums;
}
/**
* @return string
*/
public static function getAddonPath()
{
return static::ADDON_PATH;
}
/**
* @return string
*/
public static function getAddonFile()
{
return __FILE__;
}
}

222
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/onedriveaddon/src/HttpClient.php Normal file
View File

@@ -0,0 +1,222 @@
<?php
namespace Duplicator\Addons\OneDriveAddon;
use DUP_PRO_Log;
use Duplicator\Libs\Snap\SnapLog;
class HttpClient
{
/** @var string Base URL */
protected $baseUrl = '';
/** @var string Access token */
protected $accessToken = '';
/** @var int Timeout in seconds */
protected $timeout = 1000;
/** @var string Path to the certificate */
protected $sslCert = '';
/** @var bool Should verify the SSL certificate */
protected $sslVerify = true;
/** @var array<string,string> Default headers */
protected $headers = [];
/**
* Class constructor
*
* @param string $baseUrl Base URL
* @param string $accesToken Access token
* @param bool $sslVerify If true, use SSL
* @param string $sslCert If empty use server cert
* @param int $timeout Timeout in seconds
*/
public function __construct($baseUrl, $accesToken, $sslVerify = true, $sslCert = '', $timeout = 1000)
{
$this->baseUrl = $baseUrl;
$this->accessToken = $accesToken;
$this->timeout = $timeout;
$this->sslCert = $sslCert;
$this->sslVerify = $sslVerify;
$this->headers['Authorization'] = 'Bearer ' . $this->accessToken;
}
/**
* @param string $url The URL to request
* @param array<string, scalar> $data The data to send
* @param array<string, string> $headers The headers to send
*
* @return array{headers: array<string, string>, body: string, code: int}
* @throws \Exception
*/
public function get($url, $data = [], $headers = [])
{
return $this->request('GET', $url, $data, $headers);
}
/**
* @param string $url The URL to request
* @param array<string, mixed>|string $data The data to send
* @param array<string, string> $headers The headers to send
*
* @return array{headers: array<string, string>, body: string, code: int}
*/
public function post($url, $data = [], $headers = [])
{
return $this->request('POST', $url, $data, $headers);
}
/**
* @param string $url The URL to request
* @param array<string, mixed>|string $data The data to send
* @param array<string, string> $headers The headers to send
*
* @return array{headers: array<string, string>, body: string, code: int}
*/
public function put($url, $data = [], $headers = [])
{
return $this->request('PUT', $url, $data, $headers);
}
/**
* @param string $url The URL to request
* @param array<string, string> $headers The headers to send
*
* @return array{headers: array<string, string>, body: string, code: int}
*/
public function delete($url, $headers = [])
{
return $this->request('DELETE', $url, [], $headers);
}
/**
* Send a HTTP request
*
* @param string $method The request verb
* @param string $url The URL to request
* @param array<string, mixed>|string $data The data to send, arrays will be json encoded, strings will be sent as is
* @param array<string, string> $headers The headers to send
* @param array<int, scalar> $overrideOptions Override the curl options
*
* @return array{headers: array<string, string>, body: string, code: int}
*/
public function request($method, $url, $data = [], $headers = [], $overrideOptions = [])
{
$headers = array_merge($this->headers, $headers);
if (!empty($this->baseUrl) && strpos($url, 'http') !== 0) {
$url = rtrim($this->baseUrl, '/') . '/' . ltrim($url, '/');
}
$curl = curl_init();
if (!$curl) {
throw new \Exception('Could not initialize remote request using curl.');
}
if ($method === 'GET' && !empty($data)) {
$url .= '?' . http_build_query($data);
$data = [];
}
$options = [
CURLOPT_RETURNTRANSFER => true,
CURLOPT_FOLLOWLOCATION => true,
CURLOPT_AUTOREFERER => true,
CURLOPT_URL => $url,
CURLOPT_TIMEOUT => $this->timeout,
CURLOPT_CUSTOMREQUEST => $method,
CURLOPT_HEADER => true,
CURLOPT_SSL_VERIFYHOST => ($this->sslVerify ? 2 : false),
CURLOPT_SSL_VERIFYPEER => $this->sslVerify,
];
if (!empty($this->sslCert)) {
$options[CURLOPT_CAINFO] = $this->sslCert;
}
// We are sending a json payload
if (!empty($data) && is_array($data)) {
$options[CURLOPT_POSTFIELDS] = json_encode($data);
$headers['Content-Type'] = 'application/json';
} elseif (!empty($data) && is_string($data)) {
// We are sending a string payload
$options[CURLOPT_POST] = true;
$options[CURLOPT_POSTFIELDS] = $data;
}
// Format the headers for curl and set the option
$options[CURLOPT_HTTPHEADER] = $this->formatRequestHeaders($headers);
// Override the options if needed
if (!empty($overrideOptions)) {
$options = array_merge($options, $overrideOptions);
}
// Set the options
if (!curl_setopt_array($curl, $options)) {
// curl will return immediately if it fails to set one of the options
throw new \Exception('Could not set curl options.');
}
$response = curl_exec($curl);
// check for any error
$error = curl_error($curl);
if ($error || $response === false) {
throw new \Exception("Curl error: {$error}");
}
// Get the header size and the http code
$headerSize = curl_getinfo($curl, CURLINFO_HEADER_SIZE);
$httpCode = curl_getinfo($curl, CURLINFO_HTTP_CODE);
// Get the header and the body
$header = substr($response, 0, $headerSize);
$body = substr($response, $headerSize);
curl_close($curl);
return [
'headers' => $this->formatResponseHeaders($header),
'body' => $body,
'code' => (int) $httpCode,
];
}
/**
* Format the headers for curl
*
* @param array<string, string> $headers The headers to format
*
* @return string[]
*/
protected function formatRequestHeaders($headers)
{
return array_map(function ($key, $value) {
return $key . ': ' . $value;
}, array_keys($headers), $headers);
}
/**
* Format the response headers
*
* @param string $headers The headers to format
*
* @return false|string[]
*/
protected function formatResponseHeaders($headers)
{
$headers = explode("\r\n", $headers);
foreach ($headers as $index => $item) {
$item = explode(': ', $item);
if (count($item) === 2) {
$headers[trim($item[0])] = trim($item[1]);
}
unset($headers[$index]);
}
return $headers;
}
}

651
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/onedriveaddon/src/Models/OneDriveStorage.php Normal file
View File

@@ -0,0 +1,651 @@
<?php
/**
*
* @package Duplicator
* @copyright (c) 2022, Snap Creek LLC
*/
namespace Duplicator\Addons\OneDriveAddon\Models;
use DUP_PRO_Global_Entity;
use DUP_PRO_Log;
use Duplicator\Addons\OneDriveAddon\OnedriveAdapter;
use Duplicator\Addons\OneDriveAddon\OneDriveStoragePathInfo;
use Duplicator\Core\Views\TplMng;
use Duplicator\Libs\Snap\SnapUtil;
use Duplicator\Models\DynamicGlobalEntity;
use Duplicator\Models\Storages\AbstractStorageEntity;
use Duplicator\Models\Storages\StorageAuthInterface;
use Duplicator\Utils\OAuth\TokenEntity;
use Duplicator\Utils\OAuth\TokenService;
use Exception;
class OneDriveStorage extends AbstractStorageEntity implements StorageAuthInterface
{
const GRAPH_SCOPES = [
'openid',
'offline_access',
'files.readwrite.appfolder',
];
const CLIENT_ID = '15fa3a0d-b7ee-447c-8093-7bfcf30b0797';
const LOGOUT_REDIRECT_URI = 'https://snapcreek.com/misc/onedrive/redir3.php';
/**
* @var null|OneDriveAdapter Storage adapter
*/
protected $adapter = null;
/**
* Get default config
*
* @return array<string,scalar>
*/
protected static function getDefaultConfig()
{
$config = parent::getDefaultConfig();
$config = array_merge(
$config,
[
'endpoint_url' => '',
'resource_id' => '',
'access_token' => '',
'refresh_token' => '',
'token_obtained' => 0,
'storage_folder_id' => '',
'storage_folder_web_url' => '',
'all_folders_perm' => false,
'authorized' => false,
]
);
return $config;
}
/**
* Serialize
*
* Wakeup method.
*
* @return void
*/
public function __wakeup()
{
parent::__wakeup();
if ($this->legacyEntity) {
// Old storage entity
$this->legacyEntity = false;
// Make sure the storage type is right from the old entity
$this->storage_type = $this->getSType();
$this->config = [
'endpoint_url' => $this->onedrive_endpoint_url,
'resource_id' => $this->onedrive_resource_id,
'access_token' => $this->onedrive_access_token,
'refresh_token' => $this->onedrive_refresh_token,
'token_obtained' => $this->onedrive_token_obtained,
'storage_folder' => ltrim($this->onedrive_storage_folder, '/\\'),
'max_packages' => $this->onedrive_max_files,
'storage_folder_id' => $this->onedrive_storage_folder_id,
'storage_folder_web_url' => $this->onedrive_storage_folder_web_url,
'authorized' => ($this->onedrive_authorization_state == 1),
];
// reset old values
$this->onedrive_endpoint_url = '';
$this->onedrive_resource_id = '';
$this->onedrive_access_token = '';
$this->onedrive_refresh_token = '';
$this->onedrive_token_obtained = 0;
$this->onedrive_storage_folder = '';
$this->onedrive_max_files = 10;
$this->onedrive_storage_folder_id = '';
$this->onedrive_authorization_state = 0;
$this->onedrive_storage_folder_web_url = '';
}
}
/**
* Will be called, automatically, when Serialize
*
* @return array<string, mixed>
*/
public function __serialize() // phpcs:ignore PHPCompatibility.FunctionNameRestrictions.NewMagicMethods.__serializeFound
{
$data = parent::__serialize();
unset($data['client']);
return $data;
}
/**
* Return the storage type
*
* @return int
*/
public static function getSType()
{
return 7;
}
/**
* Returns the storage type icon.
*
* @return string Returns the storage icon
*/
public static function getStypeIcon()
{
$imgUrl = DUPLICATOR_PRO_IMG_URL . '/onedrive.svg';
return '<img src="' . esc_url($imgUrl) . '" class="dup-storage-icon" alt="' . esc_attr(static::getStypeName()) . '" />';
}
/**
* Returns the storage type name.
*
* @return string
*/
public static function getStypeName()
{
return __('OneDrive', 'duplicator-pro');
}
/**
* Get storage location string
*
* @return string
*/
public function getLocationString()
{
if (!$this->isAuthorized()) {
return __("Not Authenticated", "duplicator-pro");
} else {
return $this->config['storage_folder_web_url'];
}
}
/**
* Returns an html anchor tag of location
*
* @return string Returns an html anchor tag with the storage location as a hyperlink.
*
* @example
* OneDrive Example return
* <a target="_blank" href="https://1drv.ms/f/sAFrQtasdrewasyghg">https://1drv.ms/f/sAFrQtasdrewasyghg</a>
*/
public function getHtmlLocationLink()
{
if ($this->isAuthorized()) {
return '<a href="' . esc_url($this->getLocationString()) . '" target="_blank" >' . esc_html($this->getLocationString()) . '</a>';
} else {
return $this->getLocationString();
}
}
/**
* Check if storage is supported
*
* @return bool
*/
public static function isSupported()
{
return SnapUtil::isCurlEnabled();
}
/**
* Get supported notice, displayed if storage isn't supported
*
* @return string html string or empty if storage is supported
*/
public static function getNotSupportedNotice()
{
if (static::isSupported()) {
return '';
}
return esc_html__('OneDrive requires the PHP CURL extension enabled.', 'duplicator-pro');
}
/**
* Check if storage is valid
*
* @return bool Return true if storage is valid and ready to use, false otherwise
*/
public function isValid()
{
return $this->isAuthorized();
}
/**
* Is autorized
*
* @return bool
*/
public function isAuthorized()
{
return $this->config['authorized'];
}
/**
* Get the chunk size bytes
*
* @return int
*/
public function getUploadChunkSize()
{
return DynamicGlobalEntity::getInstance()->getVal('onedrive_upload_chunksize_in_kb') * KB_IN_BYTES;
}
/**
* Get upload chunk timeout in seconds
*
* @return int timeout in microseconds, 0 unlimited
*/
public function getUploadChunkTimeout()
{
$global = DUP_PRO_Global_Entity::getInstance();
return (int) ($global->php_max_worker_time_in_sec <= 0 ? 0 : $global->php_max_worker_time_in_sec * SECONDS_IN_MICROSECONDS);
}
/**
* Authorized from HTTP request
*
* @param string $message Message
*
* @return bool True if authorized, false if failed
*/
public function authorizeFromRequest(&$message = '')
{
try {
if (($refreshToken = SnapUtil::sanitizeTextInput(SnapUtil::INPUT_REQUEST, 'auth_code')) === '') {
throw new Exception(__('Authorization code is empty', 'duplicator-pro'));
}
$this->name = SnapUtil::sanitizeTextInput(SnapUtil::INPUT_REQUEST, 'name', '');
$this->notes = SnapUtil::sanitizeDefaultInput(SnapUtil::INPUT_REQUEST, 'notes', '');
$this->config['max_packages'] = SnapUtil::sanitizeIntInput(SnapUtil::INPUT_REQUEST, 'max_packages', 10);
$this->config['storage_folder'] = self::getSanitizedInputFolder('storage_folder', 'remove');
$this->revokeAuthorization();
$token = (new TokenEntity(self::getSType(), ['refresh_token' => $refreshToken]));
if (! $token->refresh(true)) {
throw new Exception(__('Failed to fetch information from OneDrive. Make sure the token is valid.', 'duplicator-pro'));
}
$this->config['access_token'] = $token->getAccessToken();
$this->config['refresh_token'] = $token->getRefreshToken();
$this->config['token_obtained'] = $token->getCreated();
$this->config['endpoint_url'] = $this->config['resource_id'] = '';
$this->config['authorized'] = true;
DUP_PRO_Log::traceObject("OneDrive App folder: ", $storageFolder = $this->getOneDriveStorageFolder());
if (! $storageFolder) {
throw new Exception("Failed to fetch information from OneDrive. Make sure the token is valid.");
}
// Get the storage folder id
$this->config['storage_folder_id'] = $storageFolder->id;
$this->config['storage_folder_web_url'] = $storageFolder->webUrl;
} catch (Exception $e) {
DUP_PRO_Log::trace("Problem authorizing OneDrive access token msg: " . $e->getMessage());
$message = $e->getMessage();
return false;
}
$message = __('OneDrive is connected successfully and Storage Provider Updated.', 'duplicator-pro');
return true;
}
/**
* Revokes authorization
*
* @param string $message Message
*
* @return bool True if authorized, false if failed
*/
public function revokeAuthorization(&$message = '')
{
if (!$this->isAuthorized()) {
$message = __('Onedrive isn\'t authorized.', 'duplicator-pro');
return true;
}
$this->config['endpoint_url'] = '';
$this->config['resource_id'] = '';
$this->config['access_token'] = '';
$this->config['refresh_token'] = '';
$this->config['token_obtained'] = 0;
$this->config['storage_folder_id'] = '';
$this->config['storage_folder_web_url'] = '';
$this->config['authorized'] = false;
$message = __('Onedrive is disconnected successfully.', 'duplicator-pro');
return true;
}
/**
* Get external revoke url
*
* @return string
*/
public function getExternalRevokeUrl()
{
$base_url = "https://login.microsoftonline.com/common/oauth2/v2.0/logout";
$fields_arr = [
"client_id" => self::CLIENT_ID,
"post_logout_redirect_uri" => self::LOGOUT_REDIRECT_URI,
];
$query = http_build_query($fields_arr);
return $base_url . "?$query";
}
/**
* Get authorization URL
*
* @return string
*/
public function getAuthorizationUrl()
{
return (new TokenService(static::getSType()))->getRedirectUri();
}
/**
* Get action key text
*
* @param string $key Key name (action, pending, failed, cancelled, success)
*
* @return string
*/
protected function getActionKeyText($key)
{
switch ($key) {
case 'action':
return sprintf(
__('Transferring to %1$s folder:<br/> <i>%2$s</i>', "duplicator-pro"),
$this->getStypeName(),
$this->getStorageFolder()
);
case 'pending':
return sprintf(
__('Transfer to %1$s folder %2$s is pending', "duplicator-pro"),
$this->getStypeName(),
$this->getStorageFolder()
);
case 'failed':
return sprintf(
__('Failed to transfer to %1$s folder %2$s', "duplicator-pro"),
$this->getStypeName(),
$this->getStorageFolder()
);
case 'cancelled':
return sprintf(
__('Cancelled before could transfer to %1$s folder %2$s', "duplicator-pro"),
$this->getStypeName(),
$this->getStorageFolder()
);
case 'success':
return sprintf(
__('Transferred package to %1$s folder %2$s', "duplicator-pro"),
$this->getStypeName(),
$this->getStorageFolder()
);
default:
throw new Exception('Invalid key');
}
}
/**
* Update all permissions
*
* @param bool $allFoldersPerm All folders permission
*
* @return bool True if success, false otherwise
*/
public function setAllPermissions($allFoldersPerm)
{
$this->config['all_folders_perm'] = $allFoldersPerm;
return $this->save();
}
/**
* Render form config fields
*
* @param bool $echo Echo or return
*
* @return string
*/
public function renderConfigFields($echo = true)
{
$hasError = $this->isAuthorized() && !$this->getAdapter()->isValid();
return TplMng::getInstance()->render(
'onedriveaddon/configs/onedrive',
[
'storage' => $this,
'storageFolder' => $this->config['storage_folder'],
'maxPackages' => $this->config['max_packages'],
'allFolderPers' => $this->config['all_folders_perm'],
'accountInfo' => $this->getAccountInfo(),
'hasError' => $hasError,
'externalRevokeUrl' => $this->getExternalRevokeUrl(),
],
$echo
);
}
/**
* Update data from http request, this method don't save data, just update object properties
*
* @param string $message Message
*
* @return bool True if success and all data is valid, false otherwise
*/
public function updateFromHttpRequest(&$message = '')
{
if ((parent::updateFromHttpRequest($message) === false)) {
return false;
}
$this->config['max_packages'] = SnapUtil::sanitizeIntInput(SnapUtil::INPUT_REQUEST, 'onedrive_msgraph_max_files', 10);
$oldFolder = $this->config['storage_folder'];
$this->config['storage_folder'] = self::getSanitizedInputFolder('_onedrive_msgraph_storage_folder', 'remove');
if ($this->isAuthorized() && $oldFolder != $this->config['storage_folder']) {
$this->config['storage_folder_id'] = '';
// Create new folder
$folder = $this->getOneDriveStorageFolder();
$this->config['storage_folder_id'] = $folder->id;
$this->config['storage_folder_web_url'] = $folder->webUrl;
$this->save();
}
$message = sprintf(
__('OneDrive Storage Updated.', 'duplicator-pro'),
$this->getStorageFolder()
);
return true;
}
/**
* Get account info
*
* @return false|object
*/
protected function getAccountInfo()
{
if (! $this->isAuthorized()) {
return false;
}
$storageFolder = $this->getOneDriveStorageFolder();
if (!$storageFolder || empty($storageFolder->user)) {
return false;
}
return (object) $storageFolder->user;
}
/**
* Get onedrive storage folder
*
* @return OneDriveStoragePathInfo|false
*/
protected function getOneDriveStorageFolder()
{
$adapter = $this->getAdapter();
if (! $adapter->isValid()) {
DUP_PRO_Log::trace("OneDrive adapter is not valid, can't get storage folder.");
return false;
}
if (!$this->config['storage_folder_id']) {
if (! $adapter->initialize($error)) {
DUP_PRO_Log::trace("Failed to initialize OneDrive adapter: $error");
return false;
}
$folder = $adapter->getPathInfo('/');
$this->config['storage_folder_id'] = $folder->id;
$this->save();
} else {
$folder = $adapter->getPathInfo('/');
}
return $folder;
}
/**
* Get stoage adapter
*
* @return OnedriveAdapter
*/
protected function getAdapter()
{
if (!$this->adapter) {
$global = DUP_PRO_Global_Entity::getInstance();
$token = $this->getTokenFromConfig();
$this->adapter = new OneDriveAdapter(
$token,
$this->config['storage_folder'],
$this->config['storage_folder_id'],
!$global->ssl_disableverify,
($global->ssl_useservercerts ? '' : DUPLICATOR_PRO_CERT_PATH)
);
if (! $this->adapter->initialize($error)) {
DUP_PRO_Log::trace("Failed to initialize OneDrive adapter: $error");
}
}
return $this->adapter;
}
/**
* Get the token entity using config values
*
* @return TokenEntity|false
*/
public function getTokenFromConfig()
{
$token = new TokenEntity(self::getSType(), [
'created' => $this->config['token_obtained'],
'expires_in' => 3600,
'scope' => self::GRAPH_SCOPES,
'access_token' => $this->config['access_token'],
'refresh_token' => $this->config['refresh_token'],
]);
if ($token->isAboutToExpire()) {
$token->refresh(true);
if (!$token->isValid()) {
return false;
}
$this->config['token_obtained'] = $token->getCreated();
$this->config['refresh_token'] = $token->getRefreshToken();
$this->config['access_token'] = $token->getAccessToken();
$this->save();
}
return $token;
}
/**
* @return void
* @throws Exception
*/
public static function registerType()
{
parent::registerType();
add_action('duplicator_update_global_storage_settings', function () {
$dGlobal = DynamicGlobalEntity::getInstance();
foreach (static::getDefaultSettings() as $key => $default) {
$value = SnapUtil::sanitizeIntInput(SnapUtil::INPUT_REQUEST, $key, $default);
$dGlobal->setVal($key, $value);
}
});
}
/**
* Get default settings
*
* @return array<string, scalar>
*/
protected static function getDefaultSettings()
{
return ['onedrive_upload_chunksize_in_kb' => DUPLICATOR_PRO_ONEDRIVE_UPLOAD_CHUNK_DEFAULT_SIZE_IN_KB];
}
/**
* @return void
*/
public static function renderGlobalOptions()
{
$values = static::getDefaultSettings();
$dGlobal = DynamicGlobalEntity::getInstance();
foreach ($values as $key => $default) {
$values[$key] = $dGlobal->getVal($key, $default);
}
?>
<h3 class="title"><?php echo esc_html(static::getStypeName()) ?></h3>
<hr size="1" />
<table class="form-table">
<tr valign="top">
<th scope="row"><label><?php esc_html_e("Upload Chunk Size", 'duplicator-pro'); ?></label></th>
<td>
<input
type="number"
name="onedrive_upload_chunksize_in_kb"
id="onedrive_upload_chunksize_in_kb"
class="dup-narrow-input text-right"
step="320"
min="<?php echo intval(DUPLICATOR_PRO_ONEDRIVE_UPLOAD_CHUNK_MIN_SIZE_IN_KB); ?>"
data-parsley-required
data-parsley-type="number"
data-parsley-errors-container="#onedrive_upload_chunksize_in_kb_error_container"
value="<?php echo (int) $values['onedrive_upload_chunksize_in_kb']; ?>"
>&nbsp;<b>KB</b>
<div id="onedrive_upload_chunksize_in_kb_error_container" class="duplicator-error-container"></div>
<p class="description">
<?php printf(esc_html__(
'How much should be uploaded to OneDrive per attempt. It should be multiple of %dkb. Higher=faster but less reliable.',
'duplicator-pro'
), (int) DUPLICATOR_PRO_ONEDRIVE_UPLOAD_CHUNK_MIN_SIZE_IN_KB);
// https://docs.microsoft.com/en-us/onedrive/developer/rest-api/api/driveitem_createuploadsession?view=odsp-graph-online#upload-bytes-to-the-upload-session
printf(
esc_html__('Default size %1$dkb. Min size %2$dkb.', 'duplicator-pro'),
(int) DUPLICATOR_PRO_ONEDRIVE_UPLOAD_CHUNK_DEFAULT_SIZE_IN_KB,
(int) DUPLICATOR_PRO_ONEDRIVE_UPLOAD_CHUNK_MIN_SIZE_IN_KB
); ?>
</p>
</td>
</tr>
</table>
<?php
}
}

27
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/onedriveaddon/src/OneDriveStoragePathInfo.php Normal file
View File

@@ -0,0 +1,27 @@
<?php
namespace Duplicator\Addons\OneDriveAddon;
use Duplicator\Models\Storages\StoragePathInfo;
class OneDriveStoragePathInfo extends StoragePathInfo
{
/** @var string */
public $id = '';
/** @var string */
public $name = '';
/** @var string */
public $webUrl = '';
/**
* @var ?array{mimeType: string, hashes: array{sha1Hash: string, quickXorHash: string, sha256Hash: string}}
*/
public $file = null;
/**
* @var array{id: string, displayName: string}|null
*/
public $user = null;
}

760
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/onedriveaddon/src/OnedriveAdapter.php Normal file
View File

@@ -0,0 +1,760 @@
<?php
namespace Duplicator\Addons\OneDriveAddon;
use DUP_PRO_Log;
use Duplicator\Models\Storages\AbstractStorageAdapter;
use Duplicator\Models\Storages\StoragePathInfo;
use Duplicator\Utils\OAuth\TokenEntity;
use Exception;
/**
* @method OneDriveStoragePathInfo getPathInfo($path)
*/
class OnedriveAdapter extends AbstractStorageAdapter
{
/** @var TokenEntity The token object to use for authentication */
protected $token = null;
/** @var HttpClient */
protected $http = null;
/** @var string The ID of the folder to use for storage */
protected $storageFolderId = '';
/** @var string The name of the folder to use for storage */
protected $storageFolderName = '';
/** @var ?OneDriveStoragePathInfo The app folder object */
protected $appFolder = null;
/** @var string Base URL for API requests */
protected $baseUrl = 'https://graph.microsoft.com/v1.0';
/** @var bool */
protected $sslVerify = true;
/** @var string If empty use server cert else use custom cert path */
protected $sslCert = '';
/** @var int The microsecond at which the current operation started */
protected $startTime = 0;
/**
* Class constructor
*
* @param TokenEntity $token The token object to use for authentication
* @param string $storageFolder The folder to use for storage
* @param string $storageFolderId The ID of the folder to use for storage
* @param bool $sslVerify If true, use SSL
* @param string $sslCert If empty use server cert
*/
public function __construct(
TokenEntity $token,
$storageFolder,
$storageFolderId = '',
$sslVerify = true,
$sslCert = ''
) {
$this->token = $token;
$this->storageFolderName = trim($storageFolder, '/');
$this->storageFolderId = $storageFolderId;
$this->sslVerify = $sslVerify;
$this->sslCert = $sslCert;
$this->http = new HttpClient($this->baseUrl, $token->getAccessToken(), $this->sslVerify, $this->sslCert);
}
/**
* Initialize the storage adapter
*
* @param string $errorMsg The error message to modify if initialization fails
*
* @return bool
*/
public function initialize(&$errorMsg = '')
{
if (! $this->token->isValid()) {
$errorMsg = __('Invalid token supplied for OneDrive', 'duplicator-pro');
return false;
}
if (! $this->exists('/') && ! $this->createDir('/')) {
$errorMsg = __('Unable to create root directory for OneDrive', 'duplicator-pro');
return false;
}
if (empty($this->storageFolderId)) {
$root = $this->getPathInfo('/');
if (! $root || ! $root->exists) {
$errorMsg = 'OneDrive root folder does not exist.';
return false;
}
$this->storageFolderId = $root->id;
}
return true;
}
/**
* Destroy the storage adapter
*
* @return bool
*/
public function destroy()
{
$storageFolder = $this->getPathInfo('/');
if (! $storageFolder || ! $storageFolder->exists) {
return true; // nothing to delete
}
return $this->delete('/', true);
}
/**
* Check if the storage adapter is valid
*
* @param string $errorMsg The error message to modify if validation fails
*
* @return bool
*/
public function isValid(&$errorMsg = '')
{
if (!$this->token->isValid() && !$this->token->refresh()) {
$errorMsg = 'Invalid token supplied or token refresh failed.';
return false;
}
$root = $this->getPathInfo('/');
if (! $root || ! $root->exists) {
$errorMsg = 'OneDrive root folder does not exist.';
return false;
}
return true;
}
/**
* Create a directory in the storage
* If the given path is a nested path, it will create all the parent directories
*
* @param string $path The path to create
*
* @return bool
*/
protected function realCreateDir($path)
{
if (empty($this->storageFolderId)) {
$parentFolder = $this->getAppFolder()->id;
$path = trim($this->storageFolderName . '/' . trim($path, '/'), '/');
} else {
$parentFolder = $this->storageFolderId;
$path = trim($path, '/');
}
$folders = explode('/', $this->formatPath($path));
$completed = '';
foreach ($folders as $folder) {
$item = $this->getItemDetailsByPath($completed . '/' . $folder);
if (!isset($item['id'])) {
try {
$item = $this->createDriveDirectory($parentFolder, $folder);
if (!isset($item['id'])) {
return false;
}
} catch (Exception $e) {
return false;
}
}
$completed .= '/' . $folder;
$parentFolder = $item['id'];
}
return true;
}
/**
* Create a file which is less that 4MB in the storage
*
* @see https://github.com/OneDrive/onedrive-api-docs/blob/live/docs/rest-api/api/driveitem_put_content.md
*
* @param string $path The path in which the file will be created
* @param string $content The content of the file
*
* @return false|int
*/
protected function realCreateFile($path, $content)
{
// maximum content length is 4MB
if (strlen($content) > 4 * 1024 * 1024) {
return false;
}
$file = ltrim($this->formatPath($path), '/');
try {
$response = $this->http->put("/me/drive/items/{$this->storageFolderId}:/{$file}:/content", $content, ['Content-Type' => 'text/plain']);
} catch (Exception $e) {
// Request failed from curl
DUP_PRO_Log::infoTrace("Failed to create file in OneDrive: {$e->getMessage()}");
return false;
}
$response = json_decode($response['body'], true);
if (!isset($response['id'])) {
return false;
}
return (int) $response['size'];
}
/**
* Delete relative path from storage root.
*
* @see https://github.com/OneDrive/onedrive-api-docs/blob/live/docs/rest-api/api/driveitem_delete.md
*
* @param string $path The path or drive item id to delete
* @param bool $recursive Whether to delete recursively
*
* @return bool
*/
protected function realDelete($path, $recursive = false)
{
if (! $this->exists($path)) {
return true;
}
$info = $this->getItemDetailsByPath($path);
if (! $recursive && isset($info['folder']) && $info['folder']['childCount'] > 0) {
return false;
}
try {
$response = $this->http->delete("/me/drive/items/{$info['id']}");
} catch (Exception $e) {
// Request failed from curl
DUP_PRO_Log::infoTrace("Failed to delete file in OneDrive: {$e->getMessage()}");
return false;
}
return $response['code'] === 204;
}
/**
* Get the contents of a file
*
* @param string $path The path to the file
*
* @return false|string
*/
public function getFileContent($path)
{
$item = $this->getItemDetailsByPath($path);
if (!isset($item['@microsoft.graph.downloadUrl'])) {
return false;
}
return file_get_contents($item['@microsoft.graph.downloadUrl']);
}
/**
* Get path info and cache it, is path not exists return path info with exists property set to false.
*
* @param string $path Relative storage path, if empty, return root path info.
*
* @return OneDriveStoragePathInfo|false The path info or false on error.
*/
protected function getRealPathInfo($path)
{
$path = '/' . ltrim($path, '/');
$item = $this->getItemDetailsByPath($path);
return $this->buildStoragePathInfo($item);
}
/**
* Move a file or directory. The destination path must not exist.
*
* @see https://github.com/OneDrive/onedrive-api-docs/blob/live/docs/rest-api/api/driveitem_move.md
*
* @param string $oldPath The path to the file or directory to move
* @param string $newPath The destination path
*
* @return bool
*/
protected function realMove($oldPath, $newPath)
{
$oldItem = $this->getPathInfo($oldPath);
$newDirectoryItem = $this->getPathInfo(dirname($newPath));
if (!$oldItem || !$newDirectoryItem) {
return false;
}
try {
$response = $this->http->request('PATCH', "/me/drive/items/{$oldItem->id}", [
'parentReference' => [
'id' => $newDirectoryItem->id,
],
'name' => basename($newPath),
]);
} catch (Exception $e) {
// Request failed error from curl
DUP_PRO_Log::infoTrace("Failed to move file in OneDrive: {$e->getMessage()}");
return false;
}
$response = json_decode($response['body'], true);
return isset($response['id']);
}
/**
* @param string $path The path to the directory to scan
* @param bool $files Whether to include files
* @param bool $folders Whether to include folders
*
* @return string[]
*/
public function scanDir($path, $files = true, $folders = true)
{
$path = '/' . ltrim($path, '/');
if ($path !== '/') {
// Paths under the storage folder must be prefixed with a colon, no need to do this for the storage folder itself
$path = ":{$path}:";
}
try {
$response = $this->http->get("/me/drive/items/{$this->storageFolderId}{$path}/children");
} catch (Exception $e) {
DUP_PRO_Log::infoTrace("Failed to scan dir in OneDrive: {$e->getMessage()}");
return [];
}
$items = json_decode($response['body'], true);
if (!isset($items['value'])) {
return [];
} else {
$items = $items['value'];
}
foreach ($items as $index => $item) {
$item = $this->buildStoragePathInfo($item);
$items[$index] = $item->name;
if (!$folders && $item->isDir) {
unset($items[$index]);
}
if (!$files && !$item->isDir) {
unset($items[$index]);
}
}
return $items;
}
/**
* Check if a directory is empty
*
* @param string $path The path to the directory
* @param string[] $filters An array of filters to apply
*
* @return bool
*/
public function isDirEmpty($path, $filters = [])
{
$item = $this->getItemDetailsByPath($path);
if (!isset($item['folder'])) {
return false;
}
if ($item['folder']['childCount'] === 0) {
return true;
} elseif (empty($filters)) {
// we have no filters, and the folder is not empty, so it must contain something
return false;
}
$regexFilters = $normalFilters = [];
foreach ($filters as $filter) {
if ($filter[0] === '/' && substr($filter, -1) === '/') {
$regexFilters[] = $filter; // It's a regex filter as it starts and ends with a slash
} else {
$normalFilters[] = $filter;
}
}
$contents = $this->scanDir($path);
foreach ($contents as $item) {
if (in_array($item, $normalFilters)) {
continue;
}
foreach ($regexFilters as $regexFilter) {
if (preg_match($regexFilter, $item) === 1) {
continue 2;
}
}
return false;
}
return true;
}
/**
* Start tracking the time for the current operation
*
* @return void
*/
protected function startTrackingTime()
{
$this->startTime = (int) (microtime(true) * SECONDS_IN_MICROSECONDS);
}
/**
* Get the elapsed time since the start of the current operation
*
* @return float
*/
protected function getElapsedTime()
{
return (int) (microtime(true) * SECONDS_IN_MICROSECONDS) - $this->startTime;
}
/**
* Check if the operation has reached the timeout
*
* @param int $timeout The timeout in microseconds
*
* @return bool
*/
protected function hasReachedTimeout($timeout)
{
return $timeout > 0 && $this->getElapsedTime() > $timeout;
}
/**
* Copy local file to storage, partial copy is supported.
* If destination file exists, it will be overwritten.
* If offset is less than the destination file size, the file will be truncated.
*
* @param string $sourceFile The source file full path
* @param string $storageFile Storage destination path
* @param int<0,max> $offset The offset where the data starts.
* @param int $length The maximum number of bytes read. Default to -1 (read all the remaining buffer).
* @param int $timeout The timeout for the copy operation in microseconds. Default to 0 (no timeout).
* @param array<string,mixed> $extraData Extra data to pass to copy function and updated during copy.
* Used for storages that need to maintain persistent data during copy intra-session.
*
* @return false|int The number of bytes that were written to the file, or false on failure.
*/
protected function realCopyToStorage($sourceFile, $storageFile, $offset = 0, $length = -1, $timeout = 0, &$extraData = [])
{
$this->startTrackingTime();
if (! isset($extraData['uploadSession'])) {
$extraData['uploadSession'] = $this->createUploadSession($storageFile);
}
$uploadSession = $extraData['uploadSession'];
if (! $uploadSession) {
DUP_PRO_Log::infoTrace("Failed to create upload session for {$storageFile}, try uploading again.");
return false;
}
$expiration = strtotime($uploadSession['expirationDateTime']);
$fileSize = filesize($sourceFile);
$defaultChunkSize = MB_IN_BYTES; // 1MB
$chunkSize = $length > 0 ? $length : $defaultChunkSize;
$stream = fopen($sourceFile, 'rb');
$bytesRemaining = $fileSize - $offset;
$bytesUploaded = $offset;
fseek($stream, $bytesUploaded);
// We stop uploading if we have reached the timeout or if we have uploaded the entire file.
while ($bytesRemaining > 0 && ! $this->hasReachedTimeout($timeout)) {
if (time() > $expiration) {
DUP_PRO_Log::infoTrace("OneDrive Upload session expired for {$storageFile}, try uploading again.");
unset($extraData['uploadSession']);
return false;
}
$chunkSize = min($chunkSize, $bytesRemaining);
$chunk = fread($stream, $chunkSize);
try {
//$this->http->setTimeout($timeout / SECONDS_IN_MICROSECONDS);
$response = $this->http->put($uploadSession['uploadUrl'], $chunk, [
'Content-Length' => $chunkSize,
'Content-Range' => sprintf('bytes %d-%d/%d', $bytesUploaded, $bytesUploaded + $chunkSize - 1, $fileSize),
]);
} catch (Exception $e) {
DUP_PRO_Log::infoTrace("Failed to copy file to OneDrive: {$e->getMessage()}");
return false;
}
$bytesUploaded += $chunkSize;
$bytesRemaining -= $chunkSize;
if (in_array($response['code'], [200, 201])) {
// We have finished uploading the file
unset($extraData['uploadSession']);
return $length > 0 ? $length : $fileSize; // We return the original requested chunksize for historical reasons.
}
// At this point only 202 is expected, which means we have to continue uploading
if ($response['code'] !== 202) {
// 4XX means we cannot resume uploading. 5XX means we can retry later.
DUP_PRO_Log::infoTrace("OneDrive Upload error for {$storageFile}, try uploading again.");
unset($extraData['uploadSession']);
return false;
}
// A specific length was requested, we have uploaded the requested length.
if ($length > 0) {
break;
}
}
// We return the original requested chunksize for historical reasons.
// @todo: This SHOULD be the number of bytes that were written to the file.
return $length > 0 ? $length : $fileSize;
}
/**
* Get the app folder object
*
* @see https://github.com/OneDrive/onedrive-api-docs/blob/live/docs/rest-api/api/drive_get_specialfolder.md
*
* @return OneDriveStoragePathInfo|false
*/
protected function getAppFolder()
{
if ($this->appFolder !== null) {
return $this->appFolder;
}
try {
$response = $this->http->get('/me/drive/special/approot');
} catch (Exception $e) {
DUP_PRO_Log::infoTrace("Failed to get app folder in OneDrive: {$e->getMessage()}");
return false;
}
$item = json_decode($response['body'], true);
return $this->appFolder = $this->buildStoragePathInfo($item);
}
/**
* Get the details of an item by path
*
* @see https://github.com/OneDrive/onedrive-api-docs/blob/live/docs/rest-api/api/driveitem_get.md#http-request
*
* @param string $path The path to the item
*
* @return array<string, mixed>|false
*/
public function getItemDetailsByPath($path)
{
$path = '/' . ltrim($this->formatPath($path), '/');
if (empty($this->storageFolderId)) {
$parent = $this->getAppFolder()->id;
$path = '/' . trim($this->storageFolderName . $path, '/');
} else {
$parent = $this->storageFolderId;
}
try {
$response = $this->http->get("me/drive/items/{$parent}:{$path}");
} catch (Exception $e) {
DUP_PRO_Log::infoTrace("Failed to get item details in OneDrive: {$e->getMessage()}");
return false;
}
return json_decode($response['body'], true);
}
/**
* Create a directory in the storage
*
* @see https://github.com/OneDrive/onedrive-api-docs/blob/live/docs/rest-api/api/driveitem_post_children.md
*
* @param string $parent The ID of the parent directory
* @param string $directory The name of the directory to create
*
* @return array<string, mixed>
*/
protected function createDriveDirectory($parent, $directory)
{
try {
$response = $this->http->post('me/drive/items/' . $parent . '/children', [
'name' => $this->formatPath($directory),
'folder' => new \stdClass(),
'@microsoft.graph.conflictBehavior' => 'fail',
]);
} catch (Exception $e) {
DUP_PRO_Log::infoTrace("Failed to create directory in OneDrive: {$e->getMessage()}");
return [];
}
return json_decode($response['body'], true);
}
/**
* Create a new upload session
*
* @see https://github.com/OneDrive/onedrive-api-docs/blob/live/docs/rest-api/api/driveitem_createuploadsession.md
*
* @param string $targetFile The path to the destination file
*
* @return array{uploadUrl: string, expirationDateTime: string}|false
*/
protected function createUploadSession($targetFile)
{
$targetFile = $this->formatPath($targetFile);
$parent = $this->storageFolderId;
$file = basename($targetFile);
if ($file !== $targetFile) {
$directory = dirname($targetFile);
$this->createDir($directory);
$targetDir = $this->getPathInfo($directory);
$parent = $targetDir->id;
}
try {
$response = $this->http->post("me/drive/items/{$parent}:/{$file}:/createUploadSession", [
'item' => ["name" => $file],
]);
} catch (Exception $e) {
// Request failed from curl
DUP_PRO_Log::infoTrace("Failed to create upload session in OneDrive: {$e->getMessage()}");
return false;
}
if ($response['code'] !== 200) {
// Failed to create the upload session, error exists in the response body
return false;
}
return json_decode($response['body'], true);
}
/**
* Build a StoragePathInfo object from the given array
*
* @param array<string, mixed> $item The array to build the object from
*
* @return OneDriveStoragePathInfo|false
*/
protected function buildStoragePathInfo($item)
{
$info = new OneDriveStoragePathInfo();
if (!isset($item['id'])) {
return $info;
}
$info->exists = true;
$info->id = $item['id'];
$info->name = $item['name'];
$info->isDir = isset($item['folder']);
$info->created = isset($item['createdDateTime']) ? strtotime($item['createdDateTime']) : 0;
$info->modified = isset($item['lastModifiedDateTime']) ? strtotime($item['lastModifiedDateTime']) : 0;
$info->size = isset($item['size']) ? $item['size'] : 0;
$info->webUrl = isset($item['webUrl']) ? $item['webUrl'] : '';
if (isset($item['file'])) {
$info->file = $item['file'];
}
if (isset($item['createdBy']['user'])) {
$info->user = $item['createdBy']['user'];
}
if (isset($item['parentReference']['path'])) {
// path can be different from the name, e.g. when the file is in a subdirectory
$fullPath = $item['parentReference']['path'] . '/' . $info->name;
$storagePosition = strpos($fullPath, $this->storageFolderName); // calculate the position of the storage folder name
$filePathStartPosition = $storagePosition + strlen($this->storageFolderName) + 1; // file path starts after the storage folder name & the slash
$info->path = substr($fullPath, $filePathStartPosition);
}
return $info;
}
/**
* Generate info on create dir
*
* @param string $path Dir path
*
* @return StoragePathInfo
*/
protected function generateCreateDirInfo($path)
{
return $this->getRealPathInfo($path);
}
/**
* Generate info on delete item
*
* @param string $path Item path
*
* @return StoragePathInfo
*/
protected function generateDeleteInfo($path)
{
$info = new OneDriveStoragePathInfo();
$info->path = $path;
$info->exists = false;
$info->isDir = false;
$info->size = 0;
$info->created = 0;
$info->modified = 0;
return $info;
}
/**
* Format a path for OneDrive. This handles special characters in the path
*
* @param string $path The path to format
*
* @return string
*/
protected function formatPath($path)
{
return implode('/', array_map('rawurlencode', explode('/', $path)));
}
/**
* Copy storage file to local file, partial copy is supported.
* If destination file exists, it will be overwritten.
* If offset is less than the destination file size, the file will be truncated.
*
* @param string $storageFile The storage file path
* @param string $destFile The destination local file full path
* @param int<0,max> $offset The offset where the data starts.
* @param int $length The maximum number of bytes read. Default to -1 (read all the remaining buffer).
* @param int $timeout The timeout for the copy operation in microseconds. Default to 0 (no timeout).
* @param array<string,mixed> $extraData Extra data to pass to copy function and updated during copy.
* Used for storages that need to maintain persistent data during copy intra-session.
*
* @return false|int The number of bytes that were written to the file, or false on failure.
*/
public function copyFromStorage($storageFile, $destFile, $offset = 0, $length = -1, $timeout = 0, &$extraData = [])
{
$this->startTrackingTime();
//$this->http->setTimeout($timeout / SECONDS_IN_MICROSECONDS);
if ($length < 0) {
// We can use the download URL to download the file in one go
$content = $this->getFileContent($storageFile);
if ($content === false) {
return false;
}
$content = substr($content, $offset);
if (file_put_contents($destFile, $content) === false) {
return false;
}
return strlen($content);
}
if (! isset($extraData['downloadUrl'])) {
$item = $this->getItemDetailsByPath($storageFile);
if (!isset($item['@microsoft.graph.downloadUrl'])) {
return false;
}
$extraData['downloadUrl'] = $item['@microsoft.graph.downloadUrl'];
if (file_put_contents($destFile, '') === false) {
DUP_PRO_Log::infoTrace("[OnedriveAddon] Failed to open file for writing: {$destFile}");
return false;
}
}
$downloadUrl = $extraData['downloadUrl'];
$range = "bytes={$offset}-" . ($offset + $length - 1);
try {
$response = $this->http->get($downloadUrl, [], ['Range' => $range]);
} catch (Exception $e) {
DUP_PRO_Log::infoTrace("[OnedriveAddon] Failed to download file: {$storageFile}. Error: {$e->getMessage()}");
return false;
}
if ($response['code'] !== 206 && $response['code'] !== 200) {
DUP_PRO_Log::infoTrace("[OnedriveAddon] Failed to download file: {$storageFile}. Response " . $response['body']);
return false;
}
file_put_contents($destFile, $response['body'], FILE_APPEND);
return $length;
}
}

304
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/onedriveaddon/template/onedriveaddon/configs/onedrive.php Normal file
View File

@@ -0,0 +1,304 @@
<?php
/**
* Duplicator messages sections
*
* @package Duplicator
* @copyright (c) 2022, Snap Creek LLC
*/
use Duplicator\Addons\OneDriveAddon\Models\OneDriveStorage;
defined("ABSPATH") or die("");
/**
* Variables
*
* @var \Duplicator\Core\Controllers\ControllersManager $ctrlMng
* @var \Duplicator\Core\Views\TplMng $tplMng
* @var array<string, mixed> $tplData
* @var OneDriveStorage $storage
*/
$storage = $tplData["storage"];
/** @var string */
$storageFolder = $tplData["storageFolder"];
/** @var int */
$maxPackages = $tplData["maxPackages"];
/** @var bool */
$allFolderPers = $tplData["allFolderPers"];
/** @var false|object */
$accountInfo = $tplData["accountInfo"];
/** @var false|object */
$hasError = $tplData["hasError"];
/** @var string */
$externalRevokeUrl = $tplData["externalRevokeUrl"];
$tplMng->render('admin_pages/storages/parts/provider_head');
?>
<tr>
<th scope="row"><label><?php esc_html_e("Authorization", 'duplicator-pro'); ?></label></th>
<td class="onedrive-authorize">
<?php if (!$storage->isAuthorized()) : ?>
<div class='onedrive-msgraph-authorization-state' id="onedrive-msgraph-state-unauthorized">
<div id="dup-all-onedrive-allperms-wrapper" >
<?php esc_html_e('All folders read write permission:', 'duplicator-pro'); ?>
<label class="switch">
<input
id="onedrive_msgraph_all_folders_read_write_perm"
name="onedrive_msgraph_all_folders_read_write_perm"
type="checkbox"
value="1"
<?php checked($allFolderPers); ?>
>
<span class="slider round"></span>
</label>
<div class="auth-code-popup-note" style="margin-top:1px; margin-left: 0;">
<?php
echo esc_html__('There is only Apps folder permission scope by default.', 'duplicator-pro') . ' ' .
esc_html__('If your OneDrive Business is not working, Please switch on this option.', 'duplicator-pro'); ?>
</div>
</div>
<!-- CONNECT -->
<button
id="dpro-onedrive-msgraph-connect-btn"
type="button"
class="button button-large"
onclick="DupPro.Storage.OneDrive.GetAuthUrl(); return false;"
>
<i class="fa fa-plug"></i> <?php esc_html_e('Connect to OneDrive', 'duplicator-pro'); ?>
<img
src="<?php echo esc_url(DUPLICATOR_PRO_IMG_URL . '/onedrive.svg'); ?>"
style='vertical-align: middle; margin:-2px 0 0 3px; height:18px; width:18px'
>
</button>
<div class='onedrive-msgraph-auth-container' style="display: none;">
<!-- STEP 2 -->
<b><?php esc_html_e("Step 1:", 'duplicator-pro'); ?></b>&nbsp;
<?php esc_html_e(' Duplicator needs to authorize at OneDrive.', 'duplicator-pro'); ?>
<div class="auth-code-popup-note" style="margin-top:1px">
<?php
esc_html_e(
'Note: Clicking the button below will open a new tab/window.
Please be sure your browser does not block popups.
If a new tab/window does not open check your browsers address bar to allow popups from this URL.',
'duplicator-pro'
);
?>
</div>
<button
id="dpro-onedrive-msgraph-auth-btn"
type="button"
class="button button-large"
data-auth-url="<?php echo esc_attr($storage->getAuthorizationUrl()); ?>"
>
<i class="fa fa-user"></i> <?php esc_html_e('Authorize Onedrive', 'duplicator-pro'); ?>
</button>
<br/><br/>
<div id="onedrive-msgraph-auth-container">
<b><?php esc_html_e('Step 2:', 'duplicator-pro'); ?></b>
<?php esc_html_e("Paste code from OneDrive authorization page.", 'duplicator-pro'); ?> <br/>
<input style="width:400px" id="onedrive-msgraph-auth-code" name="onedrive-msgraph-auth-code" />
</div>
<br><br>
<!-- STEP 3 -->
<b><?php esc_html_e("Step 3:", 'duplicator-pro'); ?></b>&nbsp;
<?php esc_html_e('Finalize OneDrive validation by clicking the "Finalize Setup" button.', 'duplicator-pro'); ?>
<br/>
<button
type="button"
id="onedrive-msgraph-finalize-setup"
class="button"
>
<i class="fa fa-check-square"></i> <?php esc_html_e('Finalize Setup', 'duplicator-pro'); ?>
</button>
</div>
</div>
<?php endif; ?>
<div class="onedrive-msgraph-authorization-state" id="onedrive-msgraph-state-authorized">
<?php if ($storage->isAuthorized()) : ?>
<h3>
<?php esc_html_e('OneDrive Account', 'duplicator-pro'); ?><br/>
<i class="dpro-edit-info">
<?php esc_html_e('Duplicator has been authorized to access this user\'s OneDrive account', 'duplicator-pro'); ?>
</i>
</h3>
<?php
if ($accountInfo !== false) {
?>
<div id="onedrive-account-info">
<label><?php esc_html_e('Name', 'duplicator-pro'); ?>:</label>
<?php echo esc_html($accountInfo->displayName); ?> <br/>
</div>
</div>
<?php
} elseif ($hasError) {
?>
<div class="error-txt">
<?php
echo '<strong>';
esc_html_e('Please click on the "Cancel Authorization" button and reauthorize the OneDrive storage', 'duplicator-pro');
echo '</strong>';
?>
</div>
<?php
}
?>
<br/>
<button type="button" class="button" onclick='DupPro.Storage.OneDrive.CancelAuthorization();'>
<?php esc_html_e('Cancel Authorization', 'duplicator-pro'); ?>
</button><br/>
<i class="dpro-edit-info">
<?php
esc_html_e(
'Disassociates storage provider with the OneDrive account. Will require re-authorization.',
'duplicator-pro'
);
?>
</i>
<?php endif; ?>
</div>
</td>
</tr>
<tr>
<th scope="row"><label for="_onedrive_msgraph_storage_folder"><?php esc_html_e("Storage Folder", 'duplicator-pro'); ?></label></th>
<td>
<b>//OneDrive/Apps/Duplicator Pro/</b>
<input
id="_onedrive_msgraph_storage_folder"
name="_onedrive_msgraph_storage_folder"
type="text"
value="<?php echo esc_attr($storageFolder); ?>"
class="dpro-storeage-folder-path" data-parsley-pattern="^((?!\:).)*[^\.\:]$"
data-parsley-errors-container="#onedrive_msgraph_storage_folder_error_container"
data-parsley-pattern-message="<?php
echo esc_attr__(
'The folder path shouldn\'t include the special character colon(":") or shouldn\'t end with a dot(".").',
'duplicator-pro'
); ?>"
>
<p>
<i>
<?php
esc_html_e(
"Folder where packages will be stored. This should be unique for each web-site using Duplicator.",
'duplicator-pro'
); ?>
</i>
</p>
<div id="onedrive_msgraph_storage_folder_error_container" class="duplicator-error-container"></div>
</td>
</tr>
<tr>
<th scope="row"><label for=""><?php esc_html_e("Max Packages", 'duplicator-pro'); ?></label></th>
<td>
<label for="onedrive_msgraph_max_files">
<input
data-parsley-errors-container="#onedrive_msgraph_max_files_error_container"
id="onedrive_msgraph_max_files"
name="onedrive_msgraph_max_files"
type="text"
value="<?php echo absint($maxPackages); ?>" maxlength="4"
>
<?php esc_html_e("Number of packages to keep in folder.", 'duplicator-pro'); ?> <br/>
<i><?php esc_html_e("When this limit is exceeded, the oldest package will be deleted. Set to 0 for no limit.", 'duplicator-pro'); ?></i>
</label>
<div id="onedrive_msgraph_max_files_error_container" class="duplicator-error-container"></div>
</td>
</tr>
<?php $tplMng->render('admin_pages/storages/parts/provider_foot');
// Alerts for OneDrive
$alertConnStatus = new DUP_PRO_UI_Dialog();
$alertConnStatus->title = __('OneDrive Connection Status', 'duplicator-pro');
$alertConnStatus->message = ''; // javascript inserted message
$alertConnStatus->initAlert();
?>
<script>
jQuery(document).ready(function ($) {
let storageId = <?php echo (int) $storage->getId(); ?>;
DupPro.Storage.OneDrive.GetAuthUrl = function ()
{
$("#dpro-onedrive-msgraph-connect-btn").hide();
$(".onedrive-msgraph-auth-container").show();
};
$('#dpro-onedrive-msgraph-auth-btn').click(function() {
let authUrl = $(this).data('auth-url');
// console.log(DupPro.Storage.OneDrive.AuthUrl);
window.open(authUrl, '_blank');
});
DupPro.Storage.OneDrive.CancelAuthorization = function ()
{
window.open(<?php echo json_encode($externalRevokeUrl); ?>, '_blank');
DupPro.Storage.RevokeAuth(storageId);
}
DupPro.Storage.OneDrive.FinalizeSetup = function () {
if ($('#onedrive-msgraph-auth-code').val().length > 5) {
$("#dup-storage-form").submit();
} else {
<?php $alertConnStatus->showAlert(); ?>
let alertMsg = "<i class='fas fa-exclamation-triangle'></i> " +
"<?php esc_html_e('Please enter your OneDrive authorization code!', 'duplicator-pro'); ?>";
<?php $alertConnStatus->updateMessage("alertMsg"); ?>
}
}
$('#onedrive_msgraph_all_folders_read_write_perm').change(function (event) {
event.stopPropagation();
let allPerms = $(this).is(':checked');
Duplicator.Util.ajaxWrapper(
{
action: 'duplicator_pro_onedrive_all_perms_update',
storage_id: storageId,
all_perms: allPerms,
nonce: '<?php echo esc_js(wp_create_nonce('duplicator_pro_onedrive_all_perms_update')); ?>'
},
function (result, data, funcData, textStatus, jqXHR) {
if (funcData.success) {
$('#dpro-onedrive-msgraph-auth-btn').data('auth-url', funcData.auth_url);
} else {
DupPro.addAdminMessage(funcData.message, 'error');
}
return '';
}
);
});
$('#onedrive-msgraph-finalize-setup').click(function (event) {
event.stopPropagation();
if ($('#onedrive-msgraph-auth-code').val().length > 5) {
DupPro.Storage.PrepareForSubmit();
//$("#dup-storage-form").submit();
DupPro.Storage.Authorize(
<?php echo (int) $storage->getId(); ?>,
<?php echo (int) $storage->getSType(); ?>,
{
'name': $('#name').val(),
'notes': $('#notes').val(),
'storage_folder': $('#_onedrive_msgraph_storage_folder').val(),
'max_packages': $('#onedrive_msgraph_max_files').val(),
'auth_code' : $('#onedrive-msgraph-auth-code').val()
}
);
} else {
<?php $alertConnStatus->showAlert(); ?>
let alertMsg = "<i class='fas fa-exclamation-triangle'></i> " +
"<?php esc_html_e('Please enter your Onedrive authorization code!', 'duplicator-pro'); ?>";
<?php $alertConnStatus->updateMessage("alertMsg"); ?>
}
return false;
});
});
</script>

180
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/probase/ProBase.php Normal file
View File

@@ -0,0 +1,180 @@
<?php
/**
* Version Pro Base addon class
*
* Name: Duplicator PRO base
* Version: 1
* Author: Duplicator
* Author URI: http://snapcreek.com
*
* PHP version 5.6.20
*
* @category Duplicator
* @package Plugin
* @author Duplicator
* @copyright 2011-2021 Snapcreek LLC
* @license https://www.gnu.org/licenses/gpl-3.0.html GPLv3
* @version GIT: $Id$
* @link https://duplicator.com/
*/
namespace Duplicator\Addons\ProBase;
// phpcs:disable
require_once __DIR__ . '/vendor/edd/EDD_SL_Plugin_Updater.php';
// phpcs:enable
use Duplicator\Controllers\SchedulePageController;
use Duplicator\Addons\ProBase\License\License;
use Duplicator\Addons\ProBase\License\LicenseNotices;
use Duplicator\Addons\ProBase\Models\LicenseData;
use Duplicator\Core\Controllers\AbstractMenuPageController;
use Duplicator\Core\MigrationMng;
use Duplicator\Installer\Models\MigrateData;
use Duplicator\Libs\Snap\SnapLog;
/**
* Version Pro Base addon class
*
* @category Duplicator
* @package Plugin
* @author Snapcreek <admin@snapcreek.com>
* @license https://www.gnu.org/licenses/gpl-3.0.html GPLv3
* @link http://snapcreek.com
*/
class ProBase extends \Duplicator\Core\Addons\AbstractAddonCore
{
/**
* @return void
*/
public function init()
{
add_action('init', array($this, 'hookInit'));
add_action('duplicator_unistall', array($this, 'unistall'));
add_filter('duplicator_main_menu_label', function () {
return 'Duplicator Pro';
});
add_filter('duplicator_menu_pages', array($this, 'addScheduleMenuField'));
add_action(MigrationMng::HOOK_FIRST_LOGIN_AFTER_INSTALL, function (MigrateData $migrationData) {
License::clearVersionCache();
});
add_action('duplicator_pro_on_upgrade_version', [$this, 'onUpgradePlugin'], 10, 2);
add_action('duplicator_before_update_crypt_setting', [__CLASS__, 'beforeCryptUpdateSettings']);
add_action('duplicator_after_update_crypt_setting', [__CLASS__, 'afterCryptUpdateSettings']);
LicenseNotices::init();
LicensingController::init();
}
/**
* Unistall
*
* @return void
*/
public function unistall()
{
if (strlen(LicenseData::getInstance()->getKey()) > 0) {
switch (LicenseData::getInstance()->deactivate()) {
case LicenseData::ACTIVATION_RESPONSE_OK:
break;
case LicenseData::ACTIVATION_REQUEST_ERROR:
SnapLog::phpErr("Error deactivate license: ACTIVATION_RESPONSE_POST_ERROR");
break;
case LicenseData::ACTIVATION_RESPONSE_INVALID:
default:
SnapLog::phpErr("Error deactivate license: ACTIVATION_RESPONSE_INVALID");
break;
}
}
}
/**
* Add schedule menu page
*
* @param array<string, AbstractMenuPageController> $basicMenuPages menu pages
*
* @return array<string, AbstractMenuPageController>
*/
public function addScheduleMenuField($basicMenuPages)
{
$page = SchedulePageController::getInstance();
$basicMenuPages[$page->getSlug()] = $page;
return $basicMenuPages;
}
/**
* Function calle on duplicator_addons_loaded hook
*
* @return void
*/
public function hookInit()
{
License::check();
}
/**
* Function called on plugin upgrade
*
* @param false|string $currentVersion current version
* @param string $newVersion new version
*
* @return void
*/
public function onUpgradePlugin($currentVersion, $newVersion)
{
if ($currentVersion !== false && version_compare($currentVersion, '4.5.16-beta1', '<')) {
$legacyKey = get_option(LicenseData::LICENSE_OLD_KEY_OPTION_NAME, '');
if (!empty($legacyKey)) {
LicenseData::getInstance()->setKey($legacyKey);
}
delete_option(LicenseData::LICENSE_OLD_KEY_OPTION_NAME);
}
License::clearVersionCache();
}
/**
* Before crypt update settings
*
* @return void
*/
public static function beforeCryptUpdateSettings()
{
// make sure the license date si reade before the settings are updated
LicenseData::getInstance();
}
/**
* After crypt update settings
*
* @return void
*/
public static function afterCryptUpdateSettings()
{
LicenseData::getInstance()->save();
}
/**
*
* @return string
*/
public static function getAddonPath()
{
return __DIR__;
}
/**
*
* @return string
*/
public static function getAddonFile()
{
return __FILE__;
}
}

94
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/probase/installer/probase/ProBase.php Normal file
View File

@@ -0,0 +1,94 @@
<?php
/**
* Version Pro Base Installer addon class
*
* Name: Duplicator PRO base
* Version: 1
* Author: Snap Creek
* Author URI: http://snapcreek.com
*
* @category Duplicator
* @package Installer
* @author Snapcreek <admin@snapcreek.com>
* @copyright 2011-2021 Snapcreek LLC
* @license https://www.gnu.org/licenses/gpl-3.0.html GPLv3
* @version GIT: $Id$
* @link http://snapcreek.com
*/
namespace Duplicator\Installer\Addons\ProBase;
use Duplicator\Installer\Core\Hooks\HooksMng;
use Duplicator\Installer\Core\Params\Items\ParamItem;
/**
* Version Pro Base Installer addon class
*
* @category Duplicator
* @package Installer
* @author Snapcreek <admin@snapcreek.com>
* @license https://www.gnu.org/licenses/gpl-3.0.html GPLv3
* @link http://snapcreek.com
*/
class ProBase extends \Duplicator\Installer\Core\Addons\InstAbstractAddonCore
{
/**
* Main init addon
*
* @return void
*/
public function init()
{
HooksMng::getInstance()->addFilter(
'dupx_main_header',
function ($value) {
return 'Duplicator PRO';
}
);
HooksMng::getInstance()->addFilter('installer_get_init_params', array(__CLASS__, 'getInitParams'));
HooksMng::getInstance()->addAction(
'after_params_overwrite',
array(
'\\Duplicator\\Installer\\Addons\\ProBase\\AdvancedParams',
'updateParamsAfterOverwrite',
)
);
}
/**
* getInitParams
*
* @param ParamItem[] $params params list
*
* @return ParamItem[]
*/
public static function getInitParams($params)
{
$advParams = array();
AdvancedParams::init($advParams);
return array_merge($params, $advParams);
}
/**
* Get addon main folder
*
* @return string
*/
public static function getAddonPath()
{
return __DIR__;
}
/**
* Get addon main file
*
* @return string
*/
public static function getAddonFile()
{
return __FILE__;
}
}

256
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/probase/installer/probase/src/AbstractLicense.php Normal file
View File

@@ -0,0 +1,256 @@
<?php
/**
*
* @package Duplicator
* @copyright (c) 2022, Snap Creek LLC
*/
namespace Duplicator\Installer\Addons\ProBase;
use Exception;
abstract class AbstractLicense
{
const TYPE_UNKNOWN = -1;
const TYPE_UNLICENSED = 0;
const TYPE_PERSONAL = 1;
const TYPE_FREELANCER = 2;
const TYPE_BUSINESS = 3;
const TYPE_PERSONAL_AUTO = 4;
const TYPE_FREELANCER_AUTO = 5;
const TYPE_BUSINESS_AUTO = 6;
const TYPE_GOLD = 7;
const TYPE_BASIC = 8;
const TYPE_PLUS = 9;
const TYPE_PRO = 10;
const TYPE_ELITE = 11;
const CAPABILITY_BRAND = 1000;
const CAPABILITY_IMPORT_SETTINGS = 1001;
const CAPABILITY_SHEDULE_HOURLY = 1002;
const CAPABILITY_MULTISITE = 1003;
const CAPABILITY_MULTISITE_PLUS = 1004;
const CAPABILITY_POWER_TOOLS = 1005;
const CAPABILITY_CHANGE_TABLE_PREFIX = 1006;
const CAPABILITY_UPDATE_AUTH = 1007;
const CAPABILITY_CAPABILITIES_MNG = 1008;
const CAPABILITY_CAPABILITIES_MNG_PLUS = 1009;
const CAPABILITY_PRO_BASE = 1010;
const CAPABILITY_PACKAGE_COMPONENTS_PLUS = 1011;
const CAPABILITY_IMPORT = 1012;
const CAPABILITY_SCHEDULE = 1013;
const CAPABILITY_STORAGE = 1014;
const CAPABILITY_TEMPLATE = 1015;
/**
* Returns the license type this installer file is made of.
*
* @return int Returns an enum type of License
*/
public static function getType()
{
// This is to avoid warnings in PHP 5.6 because isn't possibile declare an abstract static method.
throw new Exception('This method must be extended');
}
/**
* Return license limit
*
* @return int<0, max>
*/
public static function getLimit()
{
// This is to avoid warnings in PHP 5.6 because isn't possibile declare an abstract static method.
throw new Exception('This method must be extended');
}
/**
* Return upsell URL
*
* @return string
*/
public static function getUpsellURL()
{
// This is to avoid warnings in PHP 5.6 because isn't possibile declare an abstract static method.
throw new Exception('This method must be extended');
}
/**
* Return true if license is unlimited
*
* @return bool
*/
public static function isUnlimited()
{
return in_array(
static::getType(),
[
self::TYPE_BUSINESS,
self::TYPE_BUSINESS_AUTO,
self::TYPE_GOLD,
]
);
}
/**
* Return true if license have the capability
*
* @param int $capability capability key
* @param ?int $license ENUM license type, if null Get currnt licnse type
*
* @return bool
*/
public static function can($capability, $license = null)
{
if (is_null($license)) {
$license = static::getType();
}
switch ($capability) {
case self::CAPABILITY_PRO_BASE:
return true;
case self::CAPABILITY_IMPORT:
return $license > 0;
case self::CAPABILITY_MULTISITE:
return $license > 0;
case self::CAPABILITY_SCHEDULE:
return $license > 0;
case self::CAPABILITY_STORAGE:
return $license > 0;
case self::CAPABILITY_TEMPLATE:
return $license > 0;
case self::CAPABILITY_BRAND:
case self::CAPABILITY_IMPORT_SETTINGS:
case self::CAPABILITY_SHEDULE_HOURLY:
case self::CAPABILITY_POWER_TOOLS:
case self::CAPABILITY_UPDATE_AUTH:
case self::CAPABILITY_CHANGE_TABLE_PREFIX:
return in_array(
$license,
[
self::TYPE_FREELANCER,
self::TYPE_FREELANCER_AUTO,
self::TYPE_BUSINESS,
self::TYPE_BUSINESS_AUTO,
self::TYPE_GOLD,
self::TYPE_PLUS,
self::TYPE_PRO,
self::TYPE_ELITE,
]
);
case self::CAPABILITY_MULTISITE_PLUS:
case self::CAPABILITY_CAPABILITIES_MNG:
case self::CAPABILITY_CAPABILITIES_MNG_PLUS:
case self::CAPABILITY_PACKAGE_COMPONENTS_PLUS:
return in_array(
$license,
[
self::TYPE_BUSINESS,
self::TYPE_BUSINESS_AUTO,
self::TYPE_GOLD,
self::TYPE_PRO,
self::TYPE_ELITE,
]
);
default:
return false;
}
}
/**
* Return true if license can be upgraded
*
* @param ?int $license ENUM license type, if null Get currnt licnse type
*
* @return bool
*/
public static function canBeUpgraded($license = null)
{
if (is_null($license)) {
$license = static::getType();
}
return !in_array($license, [
self::TYPE_BUSINESS,
self::TYPE_BUSINESS_AUTO,
self::TYPE_GOLD,
self::TYPE_ELITE,
]);
}
/**
* Return license description
*
* @param ?int $license ENUM license type, if null Get currnt licnse type
* @param bool $article if true add article before description
*
* @return string
*/
public static function getLicenseToString($license = null, $article = false)
{
if (is_null($license)) {
$license = static::getType();
}
switch ($license) {
case self::TYPE_UNLICENSED:
return ($article ? 'an ' : '') . 'unlicensed';
case self::TYPE_PERSONAL:
case self::TYPE_PERSONAL_AUTO:
return ($article ? 'a ' : '') . 'Personal';
case self::TYPE_FREELANCER:
case self::TYPE_FREELANCER_AUTO:
return ($article ? 'a ' : '') . 'Freelancer';
case self::TYPE_BUSINESS:
case self::TYPE_BUSINESS_AUTO:
return ($article ? 'a ' : '') . 'Business';
case self::TYPE_GOLD:
return ($article ? 'a ' : '') . 'Gold';
case self::TYPE_BASIC:
return ($article ? 'a ' : '') . 'Basic';
case self::TYPE_PLUS:
return ($article ? 'a ' : '') . 'Plus';
case self::TYPE_PRO:
return ($article ? 'a ' : '') . 'Pro';
case self::TYPE_ELITE:
return ($article ? 'a ' : '') . 'Elite';
default:
return ($article ? 'an ' : '') . 'unknown license type';
}
}
/**
* Get best license from two given
*
* @param int $l1 ENUM license
* @param int $l2 ENUM license
*
* @return int ENUM license
*/
protected static function getBestLicense($l1, $l2)
{
$l1Weight = 0;
$l2Weight = 0;
$wheigts = [
self::TYPE_UNLICENSED => -1,
self::TYPE_BASIC => 0,
self::TYPE_PERSONAL => 1,
self::TYPE_PERSONAL_AUTO => 1,
self::TYPE_PLUS => 2,
self::TYPE_FREELANCER => 3,
self::TYPE_FREELANCER_AUTO => 3,
self::TYPE_PRO => 4,
self::TYPE_ELITE => 5,
self::TYPE_BUSINESS => 6,
self::TYPE_BUSINESS_AUTO => 6,
self::TYPE_GOLD => 7,
];
$l1Weight = (isset($wheigts[$l1]) ? $wheigts[$l1] : -1 );
$l2Weight = (isset($wheigts[$l2]) ? $wheigts[$l2] : -1 );
return ($l1Weight >= $l2Weight ? $l1 : $l2);
}
}

55
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/probase/installer/probase/src/AdvancedParams.php Normal file
View File

@@ -0,0 +1,55 @@
<?php
/**
* License class
*
* @category Duplicator
* @package Installer
* @author Snapcreek <admin@snapcreek.com>
* @copyright 2011-2021 Snapcreek LLC
* @license https://www.gnu.org/licenses/gpl-3.0.html GPLv3
*/
namespace Duplicator\Installer\Addons\ProBase;
use Duplicator\Installer\Core\Params\Descriptors\DescriptorInterface;
use Duplicator\Installer\Core\Params\Items\ParamForm;
use Duplicator\Installer\Core\Params\PrmMng;
use DUPX_U;
class AdvancedParams implements DescriptorInterface
{
/**
* Init advanced params
*
* @param \Duplicator\Installer\Core\Params\Items\ParamItem[] $params params list
*
* @return void
*/
public static function init(&$params)
{
$params[PrmMng::PARAM_GEN_WP_AUTH_KEY] = new ParamForm(
PrmMng::PARAM_GEN_WP_AUTH_KEY,
ParamForm::TYPE_BOOL,
ParamForm::FORM_TYPE_CHECKBOX,
array('default' => false),
array(
'label' => 'Auth Keys:',
'checkboxLabel' => 'Generate New Unique Authentication Keys and Salts',
'status' => (License::can(License::CAPABILITY_UPDATE_AUTH) ? ParamForm::STATUS_ENABLED : ParamForm::STATUS_DISABLED),
'subNote' => (License::can(License::CAPABILITY_UPDATE_AUTH) ? '' : License::getLicenseUpdateText()),
)
);
}
/**
* Update params after overwrite
*
* @param \Duplicator\Installer\Core\Params\Items\ParamItem[] $params params list
*
* @return void
*/
public static function updateParamsAfterOverwrite($params)
{
}
}

79
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/probase/installer/probase/src/License.php Normal file
View File

@@ -0,0 +1,79 @@
<?php
/**
*
* @package Duplicator
* @copyright (c) 2022, Snap Creek LLC
*/
namespace Duplicator\Installer\Addons\ProBase;
use Duplicator\Installer\Core\Params\PrmMng;
use DUPX_U;
class License extends AbstractLicense
{
/**
* Returns the license type this installer file is made of.
*
* @return int Returns an enum type of License
*/
public static function getType()
{
return self::getBestLicense(self::getImporterLicense(), self::getInstallerLicense());
}
/**
* Return license limit
*
* @return int<0, max>
*/
public static function getLimit()
{
return (int) max(0, (int) \DUPX_ArchiveConfig::getInstance()->license_limit);
}
/**
* Return upsell URL
*
* @return string
*/
public static function getUpsellURL()
{
return 'https://duplicator.com/my-account/';
}
/**
* Get license on installer from package data
*
* @return int Returns an enum type of License
*/
protected static function getInstallerLicense()
{
return \DUPX_ArchiveConfig::getInstance()->license_type;
}
/**
* Get importer license from params data
*
* @return int Returns an enum type of License
*/
protected static function getImporterLicense()
{
$overwriteData = PrmMng::getInstance()->getValue(PrmMng::PARAM_OVERWRITE_SITE_DATA);
return isset($overwriteData['dupLicense']) ? $overwriteData['dupLicense'] : self::TYPE_UNLICENSED;
}
/**
* Return license required note
*
* @return string
*/
public static function getLicenseUpdateText()
{
return 'This option isn\'t available at the <b>' . static::getLicenseToString() . '</b> license level.' .
'To enable this option ' .
'<a href="' . DUPX_U::esc_url(static::getUpsellURL()) . '" target="_blank">' . 'upgrade' . '</a>' .
' the License.';
}
}

34
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/probase/src/DrmHandler.php Normal file
View File

@@ -0,0 +1,34 @@
<?php
/**
*
* @package Duplicator
* @copyright (c) 2022, Snap Creek LLC
*/
namespace Duplicator\Addons\ProBase;
use Duplicator\Addons\ProBase\License\License;
use Duplicator\Addons\ProBase\Models\LicenseData;
class DrmHandler
{
const SCHEDULE_DRM_DELAY_DAYS = 14;
/**
* Return DRM activation days
*
* @return int -1 if has already expired, days left otherwise
*/
public static function getDaysTillDRM()
{
$status = LicenseData::getInstance()->getStatus();
if ($status !== LicenseData::STATUS_VALID && $status !== LicenseData::STATUS_EXPIRED) {
return -1;
}
if (($expiresDays = LicenseData::getInstance()->getExpirationDays()) === false) {
return -1;
}
return (self::SCHEDULE_DRM_DELAY_DAYS + $expiresDays);
}
}

263
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/probase/src/License/License.php Normal file
View File

@@ -0,0 +1,263 @@
<?php
/**
*
* @package Duplicator
* @copyright (c) 2022, Snap Creek LLC
*/
namespace Duplicator\Addons\ProBase\License;
use Duplicator\Addons\ProBase\Vendor\EDD\EDD_SL_Plugin_Updater;
use DUP_PRO_Schedule_Entity;
use Duplicator\Addons\ProBase\DrmHandler;
use Duplicator\Addons\ProBase\Models\LicenseData;
use Duplicator\Installer\Addons\ProBase\AbstractLicense;
use Duplicator\Utils\ExpireOptions;
final class License extends AbstractLicense
{
/**
* GENERAL SETTINGS
*/
const EDD_DUPPRO_STORE_URL = 'https://duplicator.com';
const EDD_DUPPRO_ITEM_NAME = 'Duplicator Pro';
const FRONTEND_CHECK_DELAY = 61; // Seconds, different fromgeneral frontend check to unsync
const FRONTEND_CHECK_DELAY_OPTION_KEY = 'license_check';
const VISIBILITY_INFO = 0;
const VISIBILITY_ALL = 1;
const VISIBILITY_NONE = 2;
/** @var ?EDD_SL_Plugin_Updater */
private static $edd_updater = null;
/**
* License check
*
* @return void
*/
public static function check()
{
if (
!is_admin() &&
ExpireOptions::getUpdate(
self::FRONTEND_CHECK_DELAY_OPTION_KEY,
true,
self::FRONTEND_CHECK_DELAY
) !== false
) {
return;
}
if (
in_array(
LicenseData::getInstance()->getStatus(),
[
LicenseData::STATUS_INVALID,
LicenseData::STATUS_UNKNOWN,
]
)
) {
return;
}
self::initEddUpdater();
}
/**
* Return true if license have the capability
*
* @param int $capability capability key
* @param ?int $license ENUM license type, if null Get currnt licnse type
*
* @return bool
*/
public static function can($capability, $license = null)
{
if (is_null($license)) {
$license = static::getType();
}
switch ($capability) {
case self::CAPABILITY_SCHEDULE:
if ($license > 0) {
return true;
}
if (count(DUP_PRO_Schedule_Entity::get_active()) > 0 && DrmHandler::getDaysTillDRM() > 0) {
return true;
}
return false;
default:
return parent::can($capability, $license);
}
}
/**
* Force upgrade check
*
* @return void
*/
public static function forceUpgradeCheck()
{
if (
in_array(
LicenseData::getInstance()->getStatus(),
[
LicenseData::STATUS_INVALID,
LicenseData::STATUS_UNKNOWN,
]
)
) {
return;
}
self::clearVersionCache();
}
/**
* Return latest version of the plugin
*
* @return string|false
*/
public static function getLatestVersion()
{
$version_info = null;
$edd_updater = self::getEddUpdater();
/** @var false|object */
$version_info = $edd_updater->get_cached_version_info();
if (is_object($version_info) && isset($version_info->new_version)) {
return $version_info->new_version;
} else {
return false;
}
}
/**
* Clear version cache
*
* @return void
*/
public static function clearVersionCache()
{
LicenseData::getInstance()->clearCache();
self::getEddUpdater()->set_version_info_cache(false);
}
/**
* Return license key
*
* @return string
*/
public static function getLicenseKey()
{
return LicenseData::getInstance()->getKey();
}
/**
* Get license status
*
* @return int
*/
public static function getLicenseStatus()
{
return LicenseData::getInstance()->getStatus();
}
/**
* Return license type
*
* @return int ENUM AbstractLicense::TYPE_*
*/
public static function getType()
{
return (
LicenseData::getInstance()->getStatus() == LicenseData::STATUS_VALID ?
LicenseData::getInstance()->getLicenseType() :
self::TYPE_UNLICENSED
);
}
/**
* Initialize the EDD Updater
*
* @return void
*/
private static function initEddUpdater()
{
if (self::$edd_updater !== null) {
return;
}
$dpro_edd_opts = array(
'version' => DUPLICATOR_PRO_VERSION,
'license' => self::getLicenseKey(),
'item_name' => self::EDD_DUPPRO_ITEM_NAME,
'author' => 'Snap Creek Software',
'wp_override' => true,
);
self::$edd_updater = new EDD_SL_Plugin_Updater(
self::EDD_DUPPRO_STORE_URL,
DUPLICATOR____FILE,
$dpro_edd_opts
);
}
/**
* Accessor that returns the EDD Updater singleton
*
* @return EDD_SL_Plugin_Updater
*/
private static function getEddUpdater()
{
if (self::$edd_updater === null) {
self::initEddUpdater();
}
return self::$edd_updater;
}
/**
* Return upsell URL
*
* @return string
*/
public static function getUpsellURL()
{
return DUPLICATOR_PRO_BLOG_URL . 'my-account/';
}
/**
* Return no activation left message
*
* @return string
*/
public static function getNoActivationLeftMessage()
{
if (self::isUnlimited()) {
$result = sprintf(__('%1$s site licenses are granted in batches of 500.', 'duplicator-pro'), License::getLicenseToString());
$result .= ' ';
$result .= sprintf(
_x(
'Please submit a %1$sticket request%2$s and we will grant you another batch.',
'%1$s and %2$s represents the opening and closing HTML tags for an anchor or link',
'duplicator-pro'
),
'<a href="' . DUPLICATOR_PRO_BLOG_URL . 'my-account/support/" target="_blank">',
'</a>'
);
$result .= '<br>';
$result .= __('This process helps to ensure that licenses are not stolen or abused for users.', 'duplicator-pro');
return $result;
} else {
return __(
'Use the link above to login to your duplicator.com dashboard to manage your licenses or upgrade to a higher license.',
'duplicator-pro'
);
}
}
}

279
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/probase/src/License/LicenseNotices.php Normal file
View File

@@ -0,0 +1,279 @@
<?php
/**
*
* @package Duplicator
* @copyright (c) 2022, Snap Creek LLC
*/
namespace Duplicator\Addons\ProBase\License;
use Duplicator\Addons\ProBase\DrmHandler;
use Duplicator\Addons\ProBase\LicensingController;
use Duplicator\Addons\ProBase\Models\LicenseData;
use Duplicator\Controllers\SettingsPageController;
use Duplicator\Core\CapMng;
use Duplicator\Core\Controllers\ControllersManager;
use Duplicator\Core\Views\TplMng;
use Duplicator\Views\AdminNotices;
class LicenseNotices
{
/**
* Init notice actions
*
* @return void
*/
public static function init()
{
add_action('admin_init', array(__CLASS__, 'adminInit'));
$path = plugin_basename(DUPLICATOR____FILE);
// Important to make this priority 11 or greater to ensure the version cache is up to date by EDD
add_action("after_plugin_row_{$path}", array(__CLASS__, 'noLicenseDisplay'), 11, 2);
}
/**
* Function called on hook admin_init
*
* @return void
*/
public static function adminInit()
{
$action = is_multisite() ? 'network_admin_notices' : 'admin_notices';
add_action($action, array(__CLASS__, 'licenseAlertCheck'));
}
/**
* Function called on hook admin_init
*
* @param string $file Path to the plugin file relative to the plugins directory
* @param array<string, mixed> $plugin An array of plugin data
*
* @return void
*/
public static function noLicenseDisplay($file, $plugin)
{
$latest_version = License::getLatestVersion();
// Only display this message when there is no update message
if (($latest_version === false) || version_compare(DUPLICATOR_PRO_VERSION, $latest_version, '>=')) {
$error_string = null;
$licenseSettingsUrl = SettingsPageController::getInstance()->getMenuLink(
LicensingController::L2_SLUG_LICENSING
);
$licenseStatus = LicenseData::getInstance()->getStatus();
if ($licenseStatus === LicenseData::STATUS_INVALID || $licenseStatus === LicenseData::STATUS_SITE_INACTIVE) {
$error_string = sprintf(
esc_html_x(
'Your Duplicator Pro license key is invalid so you aren\'t getting important updates!
%1$sActivate your license%2$s or %3$spurchase a license%4$s.',
'1,3: <a> tag, 2,4: </a> tag',
'duplicator-pro'
),
'<a href="' . esc_url($licenseSettingsUrl) . '">',
'</a>',
'<a target="_blank" href="' . esc_url(DUPLICATOR_PRO_BLOG_URL . 'pricing/') . '">',
'</a>'
);
} elseif ($licenseStatus === LicenseData::STATUS_EXPIRED) {
$license_key = License::getLicenseKey();
if ($license_key !== false) {
$renewal_url = DUPLICATOR_PRO_BLOG_URL . 'checkout?edd_license_key=' . $license_key;
$error_string = sprintf(
__(
'Your Duplicator Pro license key has expired so you aren\'t getting important updates! %1$sRenew your license now%2$s',
'duplicator-pro'
),
'<a target="_blank" href="' . esc_url($renewal_url) . '">',
'</a>'
);
}
}
if ($error_string != null) {
ob_start();
?>
<script>jQuery("[data-slug=\'duplicator-pro\']").addClass("update");</script>
<tr style="border-top-color:black" class="plugin-update-tr active" >
<td colspan="4" class="plugin-update colspanchange">
<div class="update-message notice inline notice-error notice-alt">
<p>
<?php
echo wp_kses(
$error_string,
[
'a' => [
'href' => [],
'target' => [],
],
]
);
?>
</p>
</div>
</td>
</tr>
<?php
ob_end_flush();
}
}
}
/**
* Used by the WP action hook to detect the state of the endpoint license
* which calls the various show* methods for which alert to display
*
* @return void
*/
public static function licenseAlertCheck()
{
if (
!CapMng::can(CapMng::CAP_BASIC, false) ||
ControllersManager::isCurrentPage(
ControllersManager::SETTINGS_SUBMENU_SLUG,
LicensingController::L2_SLUG_LICENSING
)
) {
return;
}
if (file_exists(DUPLICATOR_PRO_SSDIR_PATH . "/ovr.dup")) {
return;
}
//Style needs to be loaded here because css is global across wp-admin
wp_enqueue_style(
'dup-pro-plugin-style-notices',
DUPLICATOR_PRO_PLUGIN_URL . 'assets/css/admin-notices.css',
[],
DUPLICATOR_PRO_VERSION
);
$licenseData = LicenseData::getInstance();
switch ($licenseData->getStatus()) {
case LicenseData::STATUS_VALID:
break;
case LicenseData::STATUS_EXPIRED:
self::showExpired();
break;
case LicenseData::STATUS_UNKNOWN:
case LicenseData::STATUS_INVALID:
case LicenseData::STATUS_INACTIVE:
case LicenseData::STATUS_DISABLED:
case LicenseData::STATUS_SITE_INACTIVE:
default:
if ($licenseData->haveNoActivationsLeft()) {
self::showNoActivationsLeft();
} else {
self::showInvalidStandardNag();
}
break;
}
}
/**
* Shows the smaller standard nag screen
*
* @return void
*/
private static function showInvalidStandardNag()
{
$problem_text = 'missing';
$htmlMsg = TplMng::getInstance()->render(
'licensing/notices/inactive_message',
['problem' => $problem_text],
false
);
AdminNotices::displayGeneralAdminNotice(
$htmlMsg,
AdminNotices::GEN_ERROR_NOTICE,
false,
['dup-license-message'],
[],
true
);
}
/**
* Shows the license count used up alert
*
* @return void
*/
private static function showNoActivationsLeft()
{
$htmlMsg = TplMng::getInstance()->render(
'licensing/notices/no_activation_left',
[],
false
);
AdminNotices::displayGeneralAdminNotice(
$htmlMsg,
AdminNotices::GEN_ERROR_NOTICE,
false,
['dup-license-message'],
[],
true
);
}
/**
* Shows the expired message alert
*
* @return void
*/
private static function showExpired()
{
$renewal_url = DUPLICATOR_PRO_BLOG_URL . 'checkout?edd_license_key=' . License::getLicenseKey();
$htmlMsg = TplMng::getInstance()->render(
'licensing/notices/expired',
[
'renewal_url' => $renewal_url,
'schedule_disalbe_days_left' => DrmHandler::getDaysTillDRM(),
'active_schedule_present' => count(\DUP_PRO_Schedule_Entity::get_active()) > 0,
],
false
);
AdminNotices::displayGeneralAdminNotice(
$htmlMsg,
AdminNotices::GEN_ERROR_NOTICE,
false,
['dup-license-message'],
[],
true
);
}
/**
* Gets the upgrade link
*
* @param string $label The label of the link
* @param bool $echo Whether to echo the link or return it
*
* @return string
*/
public static function getUpsellLinkHTML($label = 'Upgrade', $echo = true)
{
ob_start();
?>
<a class="dup-upgrade-license-link" href="<?php echo esc_url(License::getUpsellURL()); ?>" target="_blank">
<?php echo esc_html($label); ?>
</a>
<?php
if ($echo) {
ob_end_flush();
return '';
} else {
return ob_get_clean();
}
}
}

13
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/probase/src/License/LicenseUtils.php Normal file
View File

@@ -0,0 +1,13 @@
<?php
/**
*
* @package Duplicator
* @copyright (c) 2022, Snap Creek LLC
*/
namespace Duplicator\Addons\ProBase\License;
class LicenseUtils
{
}

532
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/probase/src/LicensingController.php Normal file
View File

@@ -0,0 +1,532 @@
<?php
/**
* Version Pro Base functionalities
*
* Name: Duplicator PRO base
* Version: 1
* Author: Snap Creek
* Author URI: http://snapcreek.com
*
* @package Duplicator
* @copyright (c) 2022, Snap Creek LLC
*/
namespace Duplicator\Addons\ProBase;
use DUP_PRO_Log;
use Duplicator\Core\Controllers\ControllersManager;
use Duplicator\Addons\ProBase\License\License;
use Duplicator\Addons\ProBase\License\LicenseNotices;
use Duplicator\Addons\ProBase\Models\LicenseData;
use Duplicator\Controllers\SettingsPageController;
use Duplicator\Core\CapMng;
use Duplicator\Core\Controllers\PageAction;
use Duplicator\Core\Controllers\SubMenuItem;
use Duplicator\Core\Views\TplMng;
use Duplicator\Libs\Snap\SnapUtil;
use Duplicator\Libs\Snap\SnapWP;
use Duplicator\Views\AdminNotices;
use Exception;
class LicensingController
{
const L2_SLUG_LICENSING = 'licensing';
//License actions
const ACTION_ACTIVATE_LICENSE = 'activate_license';
const ACTION_DEACTIVATE_LICENSE = 'deactivate_license';
const ACTION_CHANGE_VISIBILITY = 'change_visibility';
const ACTION_CLEAR_KEY = 'clear_key';
const LICENSE_KEY_OPTION_AUTO_ACTIVE = 'duplicator_pro_license_auto_active';
/**
* License controller init
*
* @return void
*/
public static function init()
{
add_action('admin_init', array(__CLASS__, 'licenseAutoActive'));
add_action('admin_init', array(__CLASS__, 'forceUpgradeCheckAction'));
add_filter('duplicator_sub_menu_items_' . ControllersManager::SETTINGS_SUBMENU_SLUG, array(__CLASS__, 'licenseSubMenu'));
add_action('duplicator_render_page_content_' . ControllersManager::SETTINGS_SUBMENU_SLUG, array(__CLASS__, 'renderLicenseContent'), 10, 2);
add_filter('duplicator_page_actions_' . ControllersManager::SETTINGS_SUBMENU_SLUG, array(__CLASS__, 'pageActions'));
add_filter('duplicator_template_file', array(__CLASS__, 'getTemplateFile'), 10, 2);
}
/**
* Method call on admin_init hook
*
* @return void
*/
public static function licenseAutoActive()
{
if (($lKey = get_option(self::LICENSE_KEY_OPTION_AUTO_ACTIVE, false)) === false) {
return;
}
if (!CapMng::getInstance()->can(CapMng::CAP_LICENSE)) {
return;
}
if (($action = SettingsPageController::getInstance()->getActionByKey(self::ACTION_ACTIVATE_LICENSE)) == false) {
return;
}
delete_option(self::LICENSE_KEY_OPTION_AUTO_ACTIVE);
$redirect = $action->getUrl(['_license_key' => $lKey]);
if (wp_redirect($redirect)) {
exit;
} else {
throw new Exception(__('Error redirecting to license activation page', 'duplicator-pro'));
}
}
/**
* Return force upgrade check URL
*
* @return string
*/
public static function getForceUpgradeCheckURL()
{
return SnapWP::adminUrl('update-core.php', ['force-check' => 1]);
}
/**
* Force upgrade check action
*
* @return void
*/
public static function forceUpgradeCheckAction()
{
global $pagenow;
if ($pagenow !== 'update-core.php') {
return;
}
if (!SnapUtil::sanitizeBoolInput(SnapUtil::INPUT_REQUEST, 'force-check')) {
return;
}
License::forceUpgradeCheck();
}
/**
* Add license sub menu page
*
* @param SubMenuItem[] $subMenus sub menus
*
* @return SubMenuItem[]
*/
public static function licenseSubMenu($subMenus)
{
$subMenus[] = new SubMenuItem(self::L2_SLUG_LICENSING, __('Licensing', 'duplicator-pro'), '', CapMng::CAP_LICENSE, 100);
return $subMenus;
}
/**
* Define actions related to the license
*
* @param PageAction[] $actions Page actions array from filter
*
* @return PageAction[] Updated page actions array
*/
public static function pageActions($actions)
{
$actions[] = new PageAction(
self::ACTION_ACTIVATE_LICENSE,
array(
__CLASS__,
'activateLicense',
),
array(
ControllersManager::SETTINGS_SUBMENU_SLUG,
self::L2_SLUG_LICENSING,
)
);
$actions[] = new PageAction(
self::ACTION_DEACTIVATE_LICENSE,
array(
__CLASS__,
'deactivateLicense',
),
array(
ControllersManager::SETTINGS_SUBMENU_SLUG,
self::L2_SLUG_LICENSING,
)
);
$actions[] = new PageAction(
self::ACTION_CLEAR_KEY,
array(
__CLASS__,
'clearLicenseKey',
),
array(
ControllersManager::SETTINGS_SUBMENU_SLUG,
self::L2_SLUG_LICENSING,
)
);
$actions[] = new PageAction(
self::ACTION_CHANGE_VISIBILITY,
array(
__CLASS__,
'changeLicenseVisibility',
),
array(
ControllersManager::SETTINGS_SUBMENU_SLUG,
self::L2_SLUG_LICENSING,
)
);
return $actions;
}
/**
* Action that changes the license visibility
*
* @return array<string, mixed>
*/
public static function changeLicenseVisibility()
{
$result = array(
'license_success' => false,
'license_message' => '',
);
$global = \DUP_PRO_Global_Entity::getInstance();
$sglobal = \DUP_PRO_Secure_Global_Entity::getInstance();
$oldVisibility = $global->license_key_visible;
$newVisibility = filter_input(INPUT_POST, 'license_key_visible', FILTER_VALIDATE_INT);
$newPassword = SnapUtil::sanitizeInput(INPUT_POST, '_key_password', '');
if ($oldVisibility === $newVisibility) {
return $result;
}
switch ($newVisibility) {
case License::VISIBILITY_ALL:
if ($sglobal->lkp !== $newPassword) {
$result['license_message'] = __("Wrong password entered. Please enter the correct password.", 'duplicator-pro');
return $result;
}
$newPassword = ''; // reset password
break;
case License::VISIBILITY_NONE:
case License::VISIBILITY_INFO:
if ($oldVisibility == License::VISIBILITY_ALL) {
$password_confirmation = SnapUtil::sanitizeInput(INPUT_POST, '_key_password_confirmation', '');
if (strlen($newPassword) === 0) {
$result['license_message'] = __('Password cannot be empty.', 'duplicator-pro');
return $result;
}
if ($newPassword !== $password_confirmation) {
$result['license_message'] = __("Passwords don't match.", 'duplicator-pro');
return $result;
}
} else {
if ($sglobal->lkp !== $newPassword) {
$result['license_message'] = __("Wrong password entered. Please enter the correct password.", 'duplicator-pro');
return $result;
}
}
break;
default:
throw new Exception(__('Invalid license visibility value.', 'duplicator-pro'));
}
$global->license_key_visible = $newVisibility;
$sglobal->lkp = $newPassword;
if ($global->save() && $sglobal->save()) {
return array(
'license_success' => true,
'license_message' => __("License visibility changed", 'duplicator-pro'),
);
} else {
return array(
'license_success' => false,
'license_message' => __("Couldn't change licnse vilisiblity.", 'duplicator-pro'),
);
}
}
/**
* Action that clears the license key
*
* @return array<string, mixed>
*/
public static function clearLicenseKey()
{
$global = \DUP_PRO_Global_Entity::getInstance();
$sglobal = \DUP_PRO_Secure_Global_Entity::getInstance();
LicenseData::getInstance()->setKey('');
License::clearVersionCache();
$global->license_key_visible = License::VISIBILITY_ALL;
$sglobal->lkp = '';
if ($global->save() && $sglobal->save()) {
return array(
'license_success' => true,
'license_message' => __("License key cleared", 'duplicator-pro'),
);
} else {
return array(
'license_success' => false,
'license_message' => __("Couldn't save changes", 'duplicator-pro'),
);
}
}
/**
* Action that deactivates the license
*
* @return array<string, mixed>
*/
public static function deactivateLicense()
{
$result = array(
'license_success' => true,
'license_message' => __("License Deactivated", 'duplicator-pro'),
);
try {
$lData = LicenseData::getInstance();
$lData->clearCache();
if ($lData->getStatus() !== LicenseData::STATUS_VALID) {
$result = array(
'license_success' => true,
'license_message' => __('License already deactivated.', 'duplicator-pro'),
);
return $result;
}
switch ($lData->deactivate()) {
case LicenseData::ACTIVATION_RESPONSE_OK:
break;
case LicenseData::ACTIVATION_RESPONSE_INVALID:
throw new Exception(__('Invalid license key.', 'duplicator-pro'));
case LicenseData::ACTIVATION_REQUEST_ERROR:
$result['license_request_error'] = $lData->getLastRequestError();
throw new Exception(self::getRequestErrorMessage());
default:
throw new Exception(__('Error activating license.', 'duplicator-pro'));
}
} catch (Exception $e) {
$result['license_success'] = false;
$result['license_message'] = $e->getMessage();
}
return $result;
}
/**
* Return template file path
*
* @param string $path path to the template file
* @param string $slugTpl slug of the template
*
* @return string
*/
public static function getTemplateFile($path, $slugTpl)
{
if (strpos($slugTpl, 'licensing/') === 0) {
return ProBase::getAddonPath() . '/template/' . $slugTpl . '.php';
}
return $path;
}
/**
* Action that activates the license
*
* @return array<string, mixed>
*/
public static function activateLicense()
{
$result = array(
'license_success' => true,
'license_message' => __("License Activated", 'duplicator-pro'),
);
try {
if (($licenseKey = SnapUtil::sanitizeDefaultInput(SnapUtil::INPUT_REQUEST, '_license_key')) === false) {
throw new Exception(__('Please enter a valid key. Key should be 32 characters long.', 'duplicator-pro'));
}
if (!preg_match('/^[a-f0-9]{32}$/i', $licenseKey)) {
throw new Exception(__('Please enter a valid key. Key should be 32 characters long.', 'duplicator-pro'));
}
$lData = LicenseData::getInstance();
// make sure reset old license key if exists
self::clearLicenseKey();
$lData->setKey($licenseKey);
switch ($lData->activate()) {
case LicenseData::ACTIVATION_RESPONSE_OK:
break;
case LicenseData::ACTIVATION_RESPONSE_INVALID:
throw new Exception(__('Invalid license key.', 'duplicator-pro'));
case LicenseData::ACTIVATION_REQUEST_ERROR:
$result['license_request_error'] = $lData->getLastRequestError();
DUP_PRO_Log::traceObject('License request error', $result['license_request_error']);
throw new Exception(self::getRequestErrorMessage());
default:
throw new Exception(__('Error activating license.', 'duplicator-pro'));
}
} catch (Exception $e) {
$result['license_success'] = false;
$result['license_message'] = $e->getMessage();
}
return $result;
}
/**
* Render page content
*
* @param string[] $currentLevelSlugs current menu slugs
* @param string $innerPage current inner page, empty if not set
*
* @return void
*/
public static function renderLicenseContent($currentLevelSlugs, $innerPage)
{
switch ($currentLevelSlugs[1]) {
case self::L2_SLUG_LICENSING:
self::renderLicenseMessage();
TplMng::getInstance()->render('licensing/main');
break;
}
}
/**
* Render activation/deactivation license message
*
* @return void
*/
protected static function renderLicenseMessage()
{
$tplData = TplMng::getInstance()->getGlobalData();
if (empty($tplData['license_message'])) {
return;
}
$success = (isset($tplData['license_success']) && $tplData['license_success'] === true);
AdminNotices::displayGeneralAdminNotice(
TplMng::getInstance()->render('licensing/notices/activation_message', [], false),
($success ? AdminNotices::GEN_SUCCESS_NOTICE : AdminNotices::GEN_ERROR_NOTICE),
false,
[],
[],
true
);
}
/**
* License type viewer
*
* @return void
*/
public static function displayLicenseInfo()
{
$license_type = License::getType();
if ($license_type === License::TYPE_UNLICENSED) {
echo sprintf('<b>%s</b>', esc_html__("Unlicensed", 'duplicator-pro'));
} else {
echo '<b>' . esc_html(License::getLicenseToString()) . '</b>&nbsp;';
if (License::canBeUpgraded()) {
LicenseNotices::getUpsellLinkHTML('[' . __('upgrade', 'duplicator-pro') . ']');
}
$pt_class = License::can(License::CAPABILITY_POWER_TOOLS) ? 'far fa-check-circle' : 'far fa-circle';
$mup_class = License::can(License::CAPABILITY_MULTISITE_PLUS) ? 'far fa-check-circle' : 'far fa-circle';
$txt_lic_hdr = __('Site Licenses', 'duplicator-pro');
$txt_lic_msg = __(
'Indicates the number of sites the plugin can be active on at any one time.
At any point you may deactivate/uninstall the plugin to free up the license and use the plugin elsewhere if needed.',
'duplicator-pro'
);
$txt_pt_hdr = __('Powertools', 'duplicator-pro');
$txt_pt_msg = __(
'Enhanced features that greatly improve the productivity of serious users. Include hourly schedules,
installer branding, salt & key replacement, priority support and more.',
'duplicator-pro'
);
$txt_mup_hdr = __('Multisite Plus+', 'duplicator-pro');
$txt_mup_msg = __(
'Adds the ability to install a subsite as a standalone site,
insert a standalone site into a multisite, or insert a subsite from the same/different multisite into a multisite.',
'duplicator-pro'
);
$lic_limit = (License::isUnlimited() ? __('unlimited', 'duplicator-pro') : LicenseData::getInstance()->getLicenseLimit());
$site_count = (LicenseData::getInstance()->getSiteCount() < 0 ? '?' : LicenseData::getInstance()->getSiteCount());
ob_start();
?>
<div class="dup-license-type-info">
<i class='far fa-check-circle'></i>
<?php echo esc_html($txt_lic_hdr) . ': ' . esc_html($site_count) . ' of ' . esc_html($lic_limit); ?>
<i
class='fa fa-question-circle fa-sm'
data-tooltip-title='<?php echo esc_attr($txt_lic_hdr) ?>'
data-tooltip='<?php echo esc_attr($txt_lic_msg) ?>'
>
</i>
<br/>
<i class="<?php echo esc_attr($pt_class); ?>"></i>
<?php echo esc_html($txt_pt_hdr) ?>
<i
class='fa fa-question-circle fa-sm'
data-tooltip-title='<?php echo esc_attr($txt_pt_hdr) ?>'
data-tooltip='<?php echo esc_attr($txt_pt_msg) ?>'
>
</i>
<br/>
<i class="<?php echo esc_attr($mup_class) ?>"></i>
<?php echo esc_html($txt_mup_hdr) ?>
<i
class='fa fa-question-circle fa-sm'
data-tooltip-title='<?php echo esc_attr($txt_mup_hdr) ?>'
data-tooltip='<?php echo esc_attr($txt_mup_msg) ?>'
>
</i>
<br/>
</div>
<?php
ob_end_flush();
}
}
/**
* Returns the communication error message
*
* @return string
*/
private static function getRequestErrorMessage()
{
$result = sprintf(
__('<b>License data request failed.</b> (URL: %1$s)', 'duplicator-pro'),
License::EDD_DUPPRO_STORE_URL
);
$result .= '<br>';
$result .= sprintf(
_x(
'Please see %1$sthis FAQ entry%2$s for possible causes and resolutions.',
'%1$s and %2$s represents the opening and closing HTML tags for an anchor or link',
'duplicator-pro'
),
'<a href="' . DUPLICATOR_PRO_DUPLICATOR_DOCS_URL . 'how-to-resolve-license-activation-issues/" target="_blank">',
'</a>'
);
return $result;
}
}

447
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/probase/src/Models/LicenseData.php Normal file
View File

@@ -0,0 +1,447 @@
<?php
/**
*
* @package Duplicator
* @copyright (c) 2022, Snap Creek LLC
*/
namespace Duplicator\Addons\ProBase\Models;
use DateTime;
use DUP_PRO_Global_Entity;
use DUP_PRO_Log;
use Duplicator\Addons\ProBase\License\License;
use Duplicator\Core\Models\AbstractEntitySingleton;
use Duplicator\Installer\Addons\ProBase\AbstractLicense;
use Duplicator\Libs\Snap\SnapUtil;
use Duplicator\Utils\Crypt\CryptBlowfish;
use VendorDuplicator\Amk\JsonSerialize\JsonSerialize;
use WP_Error;
class LicenseData extends AbstractEntitySingleton
{
/**
* GENERAL SETTINGS
*/
const LICENSE_CACHE_TIME = 7 * DAY_IN_SECONDS;
const LICENSE_OLD_KEY_OPTION_NAME = 'duplicator_pro_license_key';
/**
* LICENSE STATUS
*/
const STATUS_UNKNOWN = -1;
const STATUS_VALID = 0;
const STATUS_INVALID = 1;
const STATUS_INACTIVE = 2;
const STATUS_DISABLED = 3;
const STATUS_SITE_INACTIVE = 4;
const STATUS_EXPIRED = 5;
/**
* ACTIVATION REPONSE
*/
const ACTIVATION_RESPONSE_OK = 0;
const ACTIVATION_REQUEST_ERROR = -1;
const ACTIVATION_RESPONSE_INVALID = -2;
const DEFAULT_LICENSE_DATA = [
'success' => false,
'license' => 'invalid',
'item_id' => false,
'item_name' => '',
'checksum' => '',
'expires' => '',
'payment_id' => -1,
'customer_name' => '',
'customer_email' => '',
'license_limit' => -1,
'site_count' => -1,
'activations_left' => -1,
'price_id' => AbstractLicense::TYPE_UNLICENSED,
'activeSubscription' => false,
];
/** @var string */
protected $licenseKey = '';
/** @var int */
protected $status = self::STATUS_INVALID;
/** @var int */
protected $type = AbstractLicense::TYPE_UNKNOWN;
/** @var array<string,scalar> License remote data */
protected $data = self::DEFAULT_LICENSE_DATA;
/** @var string timestamp YYYY-MM-DD HH:MM:SS UTC */
protected $lastRemoteUpdate = '';
/**
* Last error request
*
* @var array{code:int, message: string, details: string, requestDetails: string}
*/
protected $lastRequestError = [
'code' => 0,
'message' => '',
'details' => '',
'requestDetails' => '',
];
/**
* Class constructor
*/
protected function __construct()
{
}
/**
* Return entity type identifier
*
* @return string
*/
public static function getType()
{
return 'LicenseDataEntity';
}
/**
* Will be called, automatically, when Serialize
*
* @return array<string, mixed>
*/
public function __serialize() // phpcs:ignore PHPCompatibility.FunctionNameRestrictions.NewMagicMethods.__serializeFound
{
$data = JsonSerialize::serializeToData($this, JsonSerialize::JSON_SKIP_MAGIC_METHODS | JsonSerialize::JSON_SKIP_CLASS_NAME);
if (DUP_PRO_Global_Entity::getInstance()->crypt) {
$data['licenseKey'] = CryptBlowfish::encrypt($data['licenseKey'], null, true);
$data['status'] = CryptBlowfish::encrypt($data['status'], null, true);
$data['type'] = CryptBlowfish::encrypt($data['type'], null, true);
$data['data'] = CryptBlowfish::encrypt(JsonSerialize::serialize($this->data), null, true);
}
unset($data['lastRequestError']);
return $data;
}
/**
* Serialize
*
* Wakeup method.
*
* @return void
*/
public function __wakeup()
{
if (DUP_PRO_Global_Entity::getInstance()->crypt) {
$this->licenseKey = CryptBlowfish::decrypt((string) $this->licenseKey, null, true);
$this->status = (int) CryptBlowfish::decrypt((string) $this->status, null, true);
$this->type = (int) CryptBlowfish::decrypt((string) $this->type, null, true);
/** @var string PHP stan fix*/
$dataString = $this->data;
$this->data = JsonSerialize::unserialize(CryptBlowfish::decrypt($dataString, null, true));
}
if (!is_array($this->data)) {
$this->data = self::DEFAULT_LICENSE_DATA;
}
}
/**
* Set license key
*
* @param string $licenseKey License key, if empty the license key will be removed
*
* @return bool return true if license key is valid and set
*/
public function setKey($licenseKey)
{
if ($this->licenseKey === $licenseKey) {
return true;
}
if ($this->getStatus() === self::STATUS_VALID) {
// Deactivate old license
$this->deactivate();
}
if (preg_match('/^[a-f0-9]{32}$/i', $licenseKey) === 1) {
$this->licenseKey = $licenseKey;
} else {
$this->licenseKey = '';
}
return $this->clearCache();
}
/**
* Get license key
*
* @return string
*/
public function getKey()
{
return $this->licenseKey;
}
/**
* Reset license data cache
*
* @param bool $save if true save the entity
*
* @return bool return true if license data cache is reset
*/
public function clearCache($save = true)
{
$this->data = self::DEFAULT_LICENSE_DATA;
$this->status = self::STATUS_INVALID;
$this->type = AbstractLicense::TYPE_UNKNOWN;
$this->lastRemoteUpdate = '';
return ($save ? $this->save() : true);
}
/**
* Get license data.
* This function manage the license data cache.
*
* @return false|array<string,scalar> License data
*/
public function getLicenseData() {
// Override default license data to simulate a valid license.
$this->data = [
'success' => true,
'license' => 'valid',
'item_id' => 31,
'item_name' => $this->plugin_name ?? '',
'checksum' => '1415b451be1a13c283ba771ea52d38bb',
'expires' => 'lifetime',
// 'payment_id' => 31,
'customer_name' => 'GPL',
'customer_email' => 'noreply@gmail.com',
'license_limit' => 1000,
'site_count' => 1,
'activations_left' => 999,
'price_id' => '11',
'activeSubscription' => true,
];
$this->status = self::STATUS_VALID;
$this->type = AbstractLicense::TYPE_ELITE;
$this->lastRemoteUpdate = gmdate("Y-m-d H:i:s"); // Update with the current time.
return $this->data;
}
/**
* Activate license key
*
* @return int license status
*/
public function activate() {
DUP_PRO_Log::trace("License considered activated.");
return self::ACTIVATION_RESPONSE_OK;
}
public function deactivate() {
DUP_PRO_Log::trace("License considered deactivated.");
return self::ACTIVATION_RESPONSE_OK;
}
/**
* Get license status
*
* @return int ENUM self::STATUS_*
*/
public function getStatus()
{
if ($this->getLicenseData() === false) {
return self::STATUS_INVALID;
}
return $this->status;
}
/**
* Get license type
*
* @return int ENUM AbstractLicense::TYPE_*
*/
public function getLicenseType()
{
if ($this->getLicenseData() === false) {
return AbstractLicense::TYPE_UNKNOWN;
}
return $this->type;
}
/**
* Get license websites limit
*
* @return int<0, max>
*/
public function getLicenseLimit()
{
if ($this->getLicenseData() === false) {
return 0;
}
return (int) max(0, (int) $this->data['license_limit']);
}
/**
* Get site count
*
* @return int<-1, max>
*/
public function getSiteCount()
{
if ($this->getLicenseData() === false) {
return -1;
}
return (int) max(-1, (int) $this->data['site_count']);
}
/**
* Deactivate license key
*
* @return int license status
*/
/**
* Get expiration date format
*
* @param string $format date format
*
* @return string return expirtation date formatted, Unknown if license data is not available or Lifetime if license is lifetime
*/
public function getExpirationDate($format = 'Y-m-d')
{
if ($this->getLicenseData() === false) {
return 'Unknown';
}
if ($this->data['expires'] === 'lifetime') {
return 'Lifetime';
}
if (empty($this->data['expires'])) {
return 'Unknown';
}
$expirationDate = new DateTime($this->data['expires']);
return $expirationDate->format($format);
}
/**
* Return expiration license days, if is expired a negative number is returned
*
* @return false|int reutrn false on fail or number of days to expire, PHP_INT_MAX is filetime
*/
public function getExpirationDays()
{
if ($this->getLicenseData() === false) {
return false;
}
if ($this->data['expires'] === 'lifetime') {
return PHP_INT_MAX;
}
if (empty($this->data['expires'])) {
return false;
}
$expirationDate = new DateTime($this->data['expires']);
return (-1 * intval($expirationDate->diff(new DateTime())->format('%r%a')));
}
/**
* check is have no activations left
*
* @return bool
*/
public function haveNoActivationsLeft()
{
return ($this->getStatus() === self::STATUS_SITE_INACTIVE && $this->data['activations_left'] === 0);
}
/**
* Return true if have active subscription
*
* @return bool
*/
public function haveActiveSubscription()
{
if ($this->getLicenseData() === false) {
return false;
}
return $this->data['activeSubscription'];
}
/**
* Get a license rquest
*
* @param mixed[] $params request params
*
* @return false|object
*/
public function request($params) {
// Simulate a successful license check response.
$response = (object)[
'license' => 'valid',
'item_name' => License::EDD_DUPPRO_ITEM_NAME,
// Add other necessary fields here.
];
return $response;
}
/**
* Get last error request
*
* @return array{code:int, message: string, details: string}
*/
public function getLastRequestError()
{
return $this->lastRequestError;
}
/**
* Get license status from status by string
*
* @param string $eddStatus license status string
*
* @return int
*/
private static function getStatusFromEDDStatus($eddStatus)
{
switch ($eddStatus) {
case 'valid':
return self::STATUS_VALID;
case 'invalid':
return self::STATUS_INVALID;
case 'expired':
return self::STATUS_EXPIRED;
case 'disabled':
return self::STATUS_DISABLED;
case 'site_inactive':
return self::STATUS_SITE_INACTIVE;
case 'inactive':
return self::STATUS_INACTIVE;
default:
return self::STATUS_UNKNOWN;
}
}
/**
* Return license statu string by status
*
* @return string
*/
public function getLicenseStatusString()
{
switch ($this->getStatus()) {
case self::STATUS_VALID:
return __('Valid', 'duplicator-pro');
case self::STATUS_INVALID:
return __('Invalid', 'duplicator-pro');
case self::STATUS_EXPIRED:
return __('Expired', 'duplicator-pro');
case self::STATUS_DISABLED:
return __('Disabled', 'duplicator-pro');
case self::STATUS_SITE_INACTIVE:
return __('Site Inactive', 'duplicator-pro');
case self::STATUS_EXPIRED:
return __('Expired', 'duplicator-pro');
default:
return __('Unknown', 'duplicator-pro');
}
}
}

216
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/probase/template/licensing/activation.php Normal file
View File

@@ -0,0 +1,216 @@
<?php
/**
* @package Duplicator
*/
use Duplicator\Addons\ProBase\License\License;
use Duplicator\Addons\ProBase\LicensingController;
use Duplicator\Addons\ProBase\Models\LicenseData;
use Duplicator\Core\Controllers\ControllersManager;
defined("ABSPATH") or die("");
/**
* Variables
*
* @var Duplicator\Core\Controllers\ControllersManager $ctrlMng
* @var Duplicator\Core\Views\TplMng $tplMng
* @var array<string, mixed> $tplData
*/
$global = DUP_PRO_Global_Entity::getInstance();
LicenseData::getInstance()->clearCache();
$license_status = LicenseData::getInstance()->getStatus();
$license_type = License::getType();
$license_text_disabled = false;
$activate_button_text = __('Activate', 'duplicator-pro');
$license_status_text_alt = false;
switch ($license_status) {
case LicenseData::STATUS_VALID:
$license_status_style = 'color:#509B18';
$activate_button_text = __('Deactivate', 'duplicator-pro');
$license_text_disabled = true;
$license_key = License::getLicenseKey();
$license_status_text = '<b>' . __('Status: ', 'duplicator-pro') . '</b>' . __('Active', 'duplicator-pro');
$license_status_text .= '<br/>';
$license_status_text .= '<b>' . __('Expiration: ', 'duplicator-pro') . '</b>';
$license_status_text .= LicenseData::getInstance()->getExpirationDate(get_option('date_format'));
$expDays = LicenseData::getInstance()->getExpirationDays();
if ($expDays === false) {
$expDays = __('no data', 'duplicator-pro');
} elseif ($expDays <= 0) {
$expDays = __('expired', 'duplicator-pro');
} elseif ($expDays == PHP_INT_MAX) {
$expDays = __('no expiration', 'duplicator-pro');
} else {
$expDays = sprintf(__('%d days left', 'duplicator-pro'), $expDays);
}
$license_status_text .= ' (<b>' . $expDays . '</b>)';
break;
case LicenseData::STATUS_INACTIVE:
$license_status_style = 'color:#dd3d36;';
$license_status_text = __('Status: Inactive', 'duplicator-pro');
break;
case LicenseData::STATUS_SITE_INACTIVE:
$license_status_style = 'color:#dd3d36;';
$global = DUP_PRO_Global_Entity::getInstance();
if (LicenseData::getInstance()->haveNoActivationsLeft()) {
$license_status_text = __('Status: Inactive (out of site licenses).', 'duplicator-pro') . '<br>' . License::getNoActivationLeftMessage();
} else {
$license_status_text = __('Status: Inactive', 'duplicator-pro');
}
break;
case LicenseData::STATUS_EXPIRED:
$renewal_url = DUPLICATOR_PRO_BLOG_URL . 'checkout?edd_license_key=' . License::getLicenseKey();
$license_status_style = 'color:#dd3d36;';
$license_status_text = sprintf(
_x(
'Your Duplicator Pro license key has expired so you aren\'t getting important updates! %1$sRenew your license now%2$s',
'1: <a> tag, 2: </a> tag',
'duplicator-pro'
),
'<a target="_blank" href="' . $renewal_url . '">',
'</a>'
);
break;
default:
// https://duplicator.com/knowledge-base/how-to-resolve-license-activation-issues/
$license_status_style = 'color:#dd3d36;';
$license_status_text = '<b>' . __('Status: ', 'duplicator-pro') . '</b>' .
LicenseData::getInstance()->getLicenseStatusString() . '<br/>';
$license_status_text_alt = true;
break;
}
?>
<form
id="dup-license-activation-form"
action="<?php echo esc_url(ControllersManager::getCurrentLink()); ?>"
method="post"
data-parsley-validate
>
<h3 class="title"><?php esc_html_e('Activation', 'duplicator-pro') ?> </h3>
<hr size="1" />
<table class="form-table">
<?php
if ($global->license_key_visible !== License::VISIBILITY_NONE) : ?>
<tr valign="top" id="dup-tr-license-dashboard">
<th scope="row"><?php esc_html_e('Dashboard', 'duplicator-pro') ?></th>
<td>
<i class="fa fa-th-large fa-sm"></i>
<a target="_blank" href="<?php echo esc_url(DUPLICATOR_PRO_BLOG_URL . 'my-account'); ?>">
<?php
esc_html_e('Manage Account Online', 'duplicator-pro')
?>
</a>
</td>
</tr>
<tr valign="top" id="dup-tr-license-type">
<th scope="row"><?php esc_html_e('License Type', 'duplicator-pro') ?></th>
<td class="dup-license-type">
<?php LicensingController::displayLicenseInfo(); ?>
</td>
</tr>
<?php endif; ?>
<?php if ($global->license_key_visible === License::VISIBILITY_ALL) : ?>
<tr valign="top" id="dup-tr-license-key-and-description">
<th scope="row">
<label><?php esc_html_e('License Key', 'duplicator-pro'); ?></label>
</th>
<td class="dup-license-key-area">
<input
type="text"
class="dup-license-key-input"
name="_license_key"
id="_license_key"
value="<?php echo esc_attr(License::getLicenseKey()); ?>">
<br>
<p class="description">
<span style="<?php echo esc_attr($license_status_style); ?>" >
<?php
echo wp_kses(
$license_status_text,
[
'a' => [
'href' => [],
'target' => [],
],
'b' => [],
'br' => [],
]
);
?>
</span>
<?php
if ($license_status_text_alt) {
esc_html_e('If license activation fails please wait a few minutes and retry.', 'duplicator-pro');
?>
<div class="dup-license-status-notes ">
<?php
printf(
esc_html_x(
'- Failure to activate after several attempts please review %1$sfaq activation steps%2$s.',
'1 and 2 represent opening and closing anchor tags (<a> and </a>)',
'duplicator-pro'
),
'<a target="_blank" href="' . esc_url(DUPLICATOR_PRO_DUPLICATOR_DOCS_URL . 'how-to-resolve-license-activation-issues/') . '">',
'</a>'
);
?>
<br/>
<?php
printf(
esc_html_x(
'- To upgrade or renew your license visit %1$sduplicator.com%2$s.',
'1 and 2 represent opening and closing anchor tags (<a> and </a>)',
'duplicator-pro'
),
'<a target="_blank" href="' . esc_url(DUPLICATOR_PRO_BLOG_URL) . '">',
'</a>'
);
?>
<br/>
<?php esc_html_e('- A valid key is needed for plugin updates but not for functionality.', 'duplicator-pro'); ?>
</div>
<?php } ?>
</p>
</td>
</tr>
<?php endif;?>
<tr>
<th scope="row" class="dup-license-key-btns">
<label><?php esc_html_e('License Action', 'duplicator-pro'); ?></label>
</th>
<td class="dup-license-key-btns">
<?php $echostring = (($license_status != LicenseData::STATUS_VALID) ? 'true' : 'false'); ?>
<div class="dup-license-key-btns">
<?php if ($global->license_key_visible === License::VISIBILITY_ALL) : ?>
<button
id="dup-license-activation-btn"
class="button"
onclick="DupPro.Licensing.ChangeActivationStatus(<?php echo esc_js($echostring); ?>);return false;">
<?php echo esc_html($activate_button_text); ?>
</button>
<?php endif;?>
<button
id="dup-license-clear-btn"
class="button"
onclick="DupPro.Licensing.ClearActivationStatus();return false;"
>
<?php esc_html_e('Clear Key', 'duplicator-pro') ?>
</button>
</div>
</td>
</tr>
</table>
</form>

80
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/probase/template/licensing/main.php Normal file
View File

@@ -0,0 +1,80 @@
<?php
/**
* @package Duplicator
*/
use Duplicator\Addons\ProBase\License\License;
use Duplicator\Addons\ProBase\LicensingController;
defined("ABSPATH") or die("");
/**
* Variables
*
* @var Duplicator\Core\Controllers\ControllersManager $ctrlMng
* @var Duplicator\Core\Views\TplMng $tplMng
* @var array<string, mixed> $tplData
*/
$tplMng->render('licensing/activation');
$tplMng->render('licensing/visibility');
?>
<script>
jQuery(document).ready(function($) {
DupPro.Licensing = new Object();
DupPro.Licensing.VISIBILITY_ALL = <?php echo (int) License::VISIBILITY_ALL;?>;
DupPro.Licensing.VISIBILITY_INFO = <?php echo (int) License::VISIBILITY_INFO;?>;
DupPro.Licensing.VISIBILITY_NONE = <?php echo (int) License::VISIBILITY_NONE;?>;
$("#_key_password, #_key_password_confirmation").keyup(function(event) {
if (event.keyCode == 13) {
$("#show_hide").click();
}
});
DupPro.Licensing.ChangeActivationStatus = function(activate) {
if (activate) {
let licenseKey = $('.dup-license-key-input').val();
window.location.href =
<?php echo json_encode($tplData['actions'][LicensingController::ACTION_ACTIVATE_LICENSE]->getUrl()); ?> +
'&_license_key=' + encodeURIComponent(licenseKey);
} else {
window.location.href = <?php echo json_encode($tplData['actions'][LicensingController::ACTION_DEACTIVATE_LICENSE]->getUrl()); ?>;
}
return false;
}
DupPro.Licensing.ClearActivationStatus = function() {
window.location.href = <?php echo json_encode($tplData['actions'][LicensingController::ACTION_CLEAR_KEY]->getUrl()); ?>;
}
DupPro.Licensing.ChangeKeyVisibility = function(show) {
$('#dup-license-visibility-form').submit();
}
DupPro.Licensing.VisibilityTemporary = function(visibility) {
switch (visibility) {
case DupPro.Licensing.VISIBILITY_ALL:
$("#dup-tr-license-dashboard").show();
$("#dup-tr-license-type").show();
$("#dup-tr-license-key-and-description").show();
break;
case DupPro.Licensing.VISIBILITY_INFO:
$("#dup-tr-license-dashboard").show();
$("#dup-tr-license-type").show();
$("#dup-tr-license-key-and-description").hide();
break;
case DupPro.Licensing.VISIBILITY_NONE:
$("#dup-tr-license-dashboard").hide();
$("#dup-tr-license-type").hide();
$("#dup-tr-license-key-and-description").hide();
break;
default:
alert("Unexpected visibility value!");
}
}
});
</script>

68
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/probase/template/licensing/notices/activation_message.php Normal file
View File

@@ -0,0 +1,68 @@
<?php
/**
* @package Duplicator
*/
use Duplicator\Libs\Snap\SnapUtil;
defined("ABSPATH") or die("");
/**
* Variables
*
* @var Duplicator\Core\Controllers\ControllersManager $ctrlMng
* @var Duplicator\Core\Views\TplMng $tplMng
* @var array<string, mixed> $tplData
*/
if (empty($tplData['license_message'])) {
return;
}
$details = "";
if (isset($tplData['license_request_error'])) {
$details = 'Message: ' . $tplData['license_request_error']['message'] . "\n" .
'Error code: ' . $tplData['license_request_error']['code'] . "\n" .
"\n" . 'Request Details' . "\n" .
$tplData['license_request_error']['requestDetails'] .
"\n" . 'Response Details' . "\n" .
$tplData['license_request_error']['details'];
}
?>
<p>
<?php if (!$tplData['license_success']) { ?>
<i class="fa fa-exclamation-triangle"></i>&nbsp;
<?php } ?>
<?php echo esc_html($tplData['license_message']) ?>
</p>
<?php if (isset($tplData['license_request_error'])) {
?>
<textarea class="dup-error-message-textarea" disabled ><?php echo esc_textarea($details); ?></textarea>
<button
data-dup-copy-value="<?php echo esc_attr($details); ?>"
data-dup-copy-title="<?php echo esc_attr("Copy Error Message to clipboard"); ?>"
data-dup-copied-title="<?php echo esc_attr("Error Message copied to clipboard"); ?>"
class="button dup-btn-copy-error-message">
<?php esc_html_e('Copy error details', 'duplicator-pro'); ?>
</button>
<?php if (!SnapUtil::isCurlEnabled()) {
$tplMng->render('licensing/notices/curl_message');
} ?>
<p>
<?php
printf(
wp_kses(
__("If the error persists please open a ticket <a href=\"%s\">here</a> and attach the errors details.", 'duplicator-pro'),
array(
'a' => array(
'href' => array(),
),
)
),
esc_url(DUPLICATOR_PRO_BLOG_URL . 'my-account/support/')
);
?>
</p>
<?php } ?>

47
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/probase/template/licensing/notices/curl_message.php Normal file
View File

@@ -0,0 +1,47 @@
<?php
/**
* @package Duplicator
*/
use Duplicator\Views\ViewHelper;
defined("ABSPATH") or die("");
/**
* Variables
*
* @var Duplicator\Core\Controllers\ControllersManager $ctrlMng
* @var Duplicator\Core\Views\TplMng $tplMng
* @var array<string, mixed> $tplData
*/
?>
<p>
<?php
echo wp_kses(
__(
'<b>CURL isn\'t enabled.</b> This module is far more reliable for remote communication.',
'duplicator-pro'
),
ViewHelper::GEN_KSES_TAGS
);
?>
</br>
<?php esc_html_e('A possible solution to the problem could be to activate it.', 'duplicator-pro'); ?>
</br>
<?php
printf(
wp_kses(
_x(
'For detailed steps on how to enable cURL please see <b>Solution 3, Issue A</b> in %1$sthis FAQ Entry%2$s.',
'%1$s and %2$s represents the opening and closing HTML tags for an anchor or link',
'duplicator-pro'
),
ViewHelper::GEN_KSES_TAGS
),
'<a href="' . esc_url(DUPLICATOR_PRO_DUPLICATOR_DOCS_URL . 'how-to-resolve-license-activation-issues/') . '" target="_blank">',
'</a>'
);
?>
<br/>
</p>

61
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/probase/template/licensing/notices/drm_schedules_msg.php Normal file
View File

@@ -0,0 +1,61 @@
<?php
/**
* @package Duplicator
*/
use Duplicator\Addons\ProBase\License\License;
defined("ABSPATH") or die("");
/**
* Variables
*
* @var Duplicator\Core\Controllers\ControllersManager $ctrlMng
* @var Duplicator\Core\Views\TplMng $tplMng
* @var array<string, mixed> $tplData
*/
$daysLeft = $tplData['schedule_disalbe_days_left'];
$activeSchedule = $tplData['active_schedule_present'];
if ($daysLeft === false) {
return;
}
if ($activeSchedule) {
?>
<u>
<?php
if (License::can(License::CAPABILITY_SCHEDULE)) {
$message = sprintf(
_n(
'Scheduled Backups are going to be disabled <b><em>in %d day</em></b>.',
'Scheduled Backups are going to be disabled <b><em>in %d days</em></b>.',
$daysLeft,
'duplicator-pro'
),
$daysLeft
);
$message .= __(' Please renew your license to assure your backups are not interrupted.', 'duplicator-pro');
echo wp_kses(
$message,
array(
'b' => array(),
'em' => array(),
)
);
} else {
esc_html_e(
'All automatic backups have been disabeld. Please renew your license to re-enable them.',
'duplicator-pro'
);
}
?>
</u>
<?php
} else {
esc_html_e(
'Scheduled Backups.',
'duplicator-pro'
);
}

38
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/probase/template/licensing/notices/expired.php Normal file
View File

@@ -0,0 +1,38 @@
<?php
/**
* @package Duplicator
*/
defined("ABSPATH") or die("");
/**
* Variables
*
* @var Duplicator\Core\Controllers\ControllersManager $ctrlMng
* @var Duplicator\Core\Views\TplMng $tplMng
* @var array<string, mixed> $tplData
*/
$renewal_url = $tplData['renewal_url'];
?>
<span class='dashicons dashicons-warning'></span>
<div class="dup-sub-content">
<h3>
<?php esc_html_e('Warning! Your Duplicator Pro license has expired...', 'duplicator-pro');?>
</h3>
<?php esc_html_e('You\'re currently missing:', 'duplicator-pro'); ?>
<ul class="dup-pro-simple-style-disc" >
<li><?php esc_html_e('Access to Advanced Features', 'duplicator-pro'); ?></li>
<li><?php $tplMng->render('licensing/notices/drm_schedules_msg'); ?></li>
<li><?php esc_html_e('Storages Management', 'duplicator-pro'); ?></li>
<li><?php esc_html_e('Templates Management', 'duplicator-pro'); ?></li>
<li><?php esc_html_e('New Features', 'duplicator-pro'); ?></li>
<li><?php esc_html_e('Important Updates for Security Patches', 'duplicator-pro'); ?></li>
<li><?php esc_html_e('Bug Fixes', 'duplicator-pro'); ?></li>
<li><?php esc_html_e('Support Requests', 'duplicator-pro'); ?></li>
</ul>
<a class="button" target="_blank" href="<?php echo esc_url($renewal_url); ?>">
<?php esc_html_e('Renew Now!', 'duplicator-pro'); ?>
</a>
</div>

62
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/probase/template/licensing/notices/inactive_message.php Normal file
View File

@@ -0,0 +1,62 @@
<?php
/**
* @package Duplicator
*/
use Duplicator\Addons\ProBase\LicensingController;
use Duplicator\Core\Controllers\ControllersManager;
use Duplicator\Views\ViewHelper;
defined("ABSPATH") or die("");
/**
* Variables
*
* @var Duplicator\Core\Controllers\ControllersManager $ctrlMng
* @var Duplicator\Core\Views\TplMng $tplMng
* @var array<string, mixed> $tplData
*/
$img_url = plugins_url('duplicator-pro/assets/img/warning.png');
$problem_text = $tplData['problem'];
$licensing_tab_url = ControllersManager::getMenuLink(ControllersManager::SETTINGS_SUBMENU_SLUG, LicensingController::L2_SLUG_LICENSING);
?>
<span class='dashicons dashicons-warning'></span>
<div class="dup-sub-content">
<h3>
<?php
printf(
esc_html_x('Your Duplicator Pro license key is %1$s ...', '%1$s represent the license status', 'duplicator-pro'),
esc_html($tplData['problem'])
);
?>
</h3>
<?php esc_html_e('You\'re currently missing:', 'duplicator-pro'); ?>
<ul class="dup-pro-simple-style-disc" >
<li><?php esc_html_e('Access to Advanced Features', 'duplicator-pro'); ?></li>
<li><?php esc_html_e('Scheduled Backups', 'duplicator-pro'); ?></li>
<li><?php esc_html_e('Storages Management', 'duplicator-pro'); ?></li>
<li><?php esc_html_e('Templates Management', 'duplicator-pro'); ?></li>
<li><?php esc_html_e('New Features', 'duplicator-pro'); ?></li>
<li><?php esc_html_e('Important Updates for Security Patches', 'duplicator-pro'); ?></li>
<li><?php esc_html_e('Bug Fixes', 'duplicator-pro'); ?></li>
<li><?php esc_html_e('Support Requests', 'duplicator-pro'); ?></li>
</ul>
<?php
printf(
wp_kses(
_x(
'<b>Please %1$sActivate Your License%2$s</b>. If you do not have a license key go to %3$sduplicator.com%4$s to get it.',
'1 and 2 are opening and 3 and 4 are closing anchor tags (<a> and </a>)',
'duplicator-pro'
),
ViewHelper::GEN_KSES_TAGS
),
'<a href="' . esc_url($licensing_tab_url) . '">',
'</a>',
'<a target="_blank" href="' . esc_url(DUPLICATOR_PRO_BLOG_URL . 'my-account') . '">',
'</a>'
);
?>
</div>

60
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/probase/template/licensing/notices/no_activation_left.php Normal file
View File

@@ -0,0 +1,60 @@
<?php
/**
* @package Duplicator
*/
use Duplicator\Addons\ProBase\LicensingController;
use Duplicator\Core\Controllers\ControllersManager;
defined("ABSPATH") or die("");
/**
* Variables
*
* @var Duplicator\Core\Controllers\ControllersManager $ctrlMng
* @var Duplicator\Core\Views\TplMng $tplMng
* @var array<string, mixed> $tplData
*/
$licensing_tab_url = ControllersManager::getMenuLink(ControllersManager::SETTINGS_SUBMENU_SLUG, LicensingController::L2_SLUG_LICENSING);
$dashboard_url = DUPLICATOR_PRO_BLOG_URL . 'my-account';
$img_url = plugins_url('duplicator-pro/assets/img/warning.png');
?>
<span class='dashicons dashicons-warning'></span>
<div class="dup-sub-content">
<h3>
<?php esc_html_e('Duplicator Pro\'s license is deactivated because you\'re out of site activations.', 'duplicator-pro'); ?>
</h3>
<?php esc_html_e('You\'re currently missing:', 'duplicator-pro'); ?>
<ul class="dup-pro-simple-style-disc" >
<li><?php esc_html_e('Access to Advanced Features', 'duplicator-pro'); ?></li>
<li><?php esc_html_e('Scheduled Backups', 'duplicator-pro'); ?></li>
<li><?php esc_html_e('Storages Management', 'duplicator-pro'); ?></li>
<li><?php esc_html_e('Templates Management', 'duplicator-pro'); ?></li>
<li><?php esc_html_e('New Features', 'duplicator-pro'); ?></li>
<li><?php esc_html_e('Important Updates for Security Patches', 'duplicator-pro'); ?></li>
<li><?php esc_html_e('Bug Fixes', 'duplicator-pro'); ?></li>
<li><?php esc_html_e('Support Requests', 'duplicator-pro'); ?></li>
</ul>
<?php
printf(
wp_kses(
_x(
'Upgrade your license using the %1$sDuplicator Dashboard%2$s or deactivate plugin on old sites.<br/>
After making necessary changes %3$srefresh the license status%4$s.',
'1 and 2 are opening and 3 and 4 are closing anchor tags (<a> and </a>)',
'duplicator-pro'
),
[
'br' => [],
]
),
'<a href="' . esc_url($dashboard_url) . '" target="_blank">',
'</a>',
'<a href="' . esc_url($licensing_tab_url) . '">',
'</a>'
);
?>
</div>

113
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/probase/template/licensing/visibility.php Normal file
View File

@@ -0,0 +1,113 @@
<?php
/**
* @package Duplicator
*/
use Duplicator\Addons\ProBase\License\License;
use Duplicator\Addons\ProBase\LicensingController;
use Duplicator\Core\Controllers\ControllersManager;
defined("ABSPATH") or die("");
/**
* Variables
*
* @var Duplicator\Core\Controllers\ControllersManager $ctrlMng
* @var Duplicator\Core\Views\TplMng $tplMng
* @var array<string, mixed> $tplData
*/
$global = DUP_PRO_Global_Entity::getInstance();
?>
<h3 class="title"><?php esc_html_e("Key Visibility", 'duplicator-pro') ?> </h3>
<small>
<?php
esc_html_e(
"This is an optional setting that prevents the 'License Key' from being copied.
Select the desired visibility mode, enter a password and hit the 'Change Visibility' button.",
'duplicator-pro'
);
echo '<br/>';
esc_html_e("Note: the password can be anything, it does not have to be the same as the WordPress user password.", 'duplicator-pro');
?>
</small>
<hr size="1" />
<form
id="dup-license-visibility-form"
action="<?php echo esc_url(ControllersManager::getCurrentLink()); ?>"
method="post"
data-parsley-validate
>
<?php $tplData['actions'][LicensingController::ACTION_CHANGE_VISIBILITY]->getActionNonceFileds(); ?>
<table class="form-table">
<tr valign="top">
<th scope="row"><label><?php esc_html_e("Visibility", 'duplicator-pro'); ?></label></th>
<td>
<label class="margin-right-1">
<input
type="radio"
name="license_key_visible"
value="<?php echo (int) License::VISIBILITY_ALL;?>"
onclick="DupPro.Licensing.VisibilityTemporary(<?php echo (int) License::VISIBILITY_ALL;?>);"
<?php checked($global->license_key_visible, License::VISIBILITY_ALL); ?>
>
<?php esc_html_e("License Visible", 'duplicator-pro'); ?>
</label>
<label class="margin-right-1">
<input
type="radio"
name="license_key_visible"
value="<?php echo (int) License::VISIBILITY_INFO;?>"
onclick="DupPro.Licensing.VisibilityTemporary(<?php echo (int) License::VISIBILITY_INFO;?>);"
<?php checked($global->license_key_visible, License::VISIBILITY_INFO); ?>
>
<?php esc_html_e("Info Only", 'duplicator-pro'); ?>
</label>
<label>
<input
type="radio"
name="license_key_visible"
value="<?php echo (int) License::VISIBILITY_NONE;?>"
onclick="DupPro.Licensing.VisibilityTemporary(<?php echo (int) License::VISIBILITY_NONE;?>);"
<?php checked($global->license_key_visible, License::VISIBILITY_NONE); ?>
>
<?php esc_html_e("License Invisible", 'duplicator-pro'); ?>
</label>
</td>
</tr>
<tr valign="top">
<th scope="row"><label><?php esc_html_e("Password", 'duplicator-pro'); ?></label></th>
<td>
<input type="password" class="dup-wide-input" name="_key_password" id="_key_password" size="50" />
</td>
</tr>
<?php if ($global->license_key_visible == License::VISIBILITY_ALL) { ?>
<tr valign="top">
<th scope="row"><label><?php esc_html_e("Retype Password", 'duplicator-pro'); ?></label></th>
<td>
<input
type="password"
class="dup-wide-input"
name="_key_password_confirmation"
id="_key_password_confirmation"
data-parsley-equalto="#_key_password"
size="50"
>
</td>
</tr>
<?php } ?>
<tr valign="top">
<th scope="row"></th>
<td>
<button
class="button"
id="show_hide"
onclick="DupPro.Licensing.ChangeKeyVisibility(); return false;"
>
<?php esc_html_e('Change Visibility', 'duplicator-pro'); ?>
</button>
</td>
</tr>
</table>
</form>

67
wp-content/plugins/duplicator-pro-v4.5.16.2/addons/test/Test.php Normal file
View File

@@ -0,0 +1,67 @@
<?php
/**
* Test addon main class
*
* Version: 0.1
* Addon URI: http://addon.test
* Description: This is test addon
* Author: Snap Creek
* Author URI: http://snapcreek.com
* Requires WP min version: 5.0
* Requires PHP: 8.0.0
* Requires Duplicator min version: 4.0.0
* Requires addons:
*
* @package Duplicator
* @subpackage Addons\Test
* @copyright (c) 2022, Snap Creek LLC
*/
namespace Duplicator\Addons\Test;
class Test extends \Duplicator\Core\Addons\AbstractAddonCore
{
/**
* Undocumented function
*
* @return void
*/
public function init()
{
add_action('duplicator_addons_loaded', array($this, 'addonsLoaded'));
}
/**
* Undocumented function
*
* @return boolean
*/
public function canEnable()
{
return false;
}
/**
* Undocumented function
*
* @return void
*/
public function addonsLoaded()
{
echo '<pre>';
var_dump($this->addonData);
echo '</pre>';
die;
}
/**
* Return addon file path
*
* @return string
*/
public static function getAddonFile()
{
return __FILE__;
}
}

115
wp-content/plugins/duplicator-pro-v4.5.16.2/assets/css/admin-notices.css Normal file
View File

@@ -0,0 +1,115 @@
/*! ================================================
* DUPLICATOR NOTICES STYLE
* Copyright:Snap Creek LLC 2015-2021
* ================================================ */
.duplicator-gen-admin-notice {
position: relative;
}
.duplicator-gen-admin-notice .notice-dismiss {
text-decoration: none;
}
.dpro-admin-notice {
background: #fff;
border-left-width: 4px;
border-left-style: solid;
border-top: 4px;
width: calc(100% - 22px);
padding: 10px;
overflow: hidden;
box-sizing: border-box;
}
.wrap .dpro-admin-notice {
width: 100%;
}
.dup-border-left-red-notice {
background: #fff;
border-left: 4px solid #ED494D;
padding: 10px;
}
.dpro-admin-notice p {
overflow: hidden;
}
.dpro-admin-notice.dpro-yellow-border {
border-left-color: #dba617;
}
.dup-updated {
margin-left: 0;
background: #fff;
border-left: 4px solid #fff;
box-shadow: 0 1px 1px 0 rgba( 0, 0, 0, 0.1);
margin: 5px 15px 2px;
padding: 1px 12px;
}
.dup-updated p {
margin: 0.5em 0;
padding: 2px;
}
.dup-updated a {
padding-bottom: 2px;
}
.dup-updated {
border-left-color: #46b450;
}
.wrap .dup-updated {
margin: 5px 0 15px;
margin: 20px 0 10px 0;
padding: 5px 10px;
font-size: 14px;
line-height: 175%;
}
.dpro-invalid-license {
text-align: center;
font-size: 16px;
line-height: 22px
}
.dpro-invalid-license h2 {
font-size:30px;
text-shadow: 0px 5px 5px #d8d8d8;
color: red;
margin: 30px 0 20Px 0;
}
.dpro-invalid-license p {
font-size: 1.25em;
}
.dpro-invalid-license small {
font-size: 0.8rem;
}
/** LICENSE NOTICES **/
.dpro-admin-notice.dup-license-message {
padding: 10px;
display: flex;
}
.dup-license-message h3 {
margin: 0 0 10px 0;
}
.dup-license-message .dashicons {
display:inline-block;
font-size:60px;
width:60px;
height:60px;
margin-right: 10px;
}
.dup-license-message .dup-pro-simple-style-disc {
margin: 10px 20px;
}

216
wp-content/plugins/duplicator-pro-v4.5.16.2/assets/css/admin-notifications.css Normal file
View File

@@ -0,0 +1,216 @@
#dup-notifications {
position: relative;
background: #ffffff 0 0 no-repeat padding-box;
box-shadow: 0 2px 4px rgba(0, 0, 0, 0.05);
border-radius: 6px;
opacity: 1;
min-height: 48px;
margin: 10px 0 20px 0;
}
#dup-notifications * {
box-sizing: border-box;
}
#dup-notifications .dup-notifications-header {
display: flex;
align-items: center;
padding: 10px 16px;
border-bottom: 1px solid rgba(204, 208, 212, 0.5);
}
#dup-notifications .dup-notifications-header .dup-notifications-bell {
position: relative;
width: 16px;
height: 20px;
top: 3px;
margin-right: 10px;
}
#dup-notifications .dup-notifications-header .dup-notifications-circle {
position: absolute;
width: 11px;
height: 11px;
border-radius: 50%;
top: -4px;
right: -1px;
border: 2px solid #ffffff;
}
#dup-notifications .dup-notifications-header .dup-notifications-title {
font-style: normal;
font-weight: 500;
font-size: 14px;
line-height: 17px;
color: #23282d;
}
#dup-notifications .dup-notifications-body {
position: relative;
}
#dup-notifications .dup-notifications-messages {
padding: 16px 100px 16px 16px;
}
#dup-notifications .dup-notifications-messages .dup-notifications-message {
display: none;
}
#dup-notifications .dup-notifications-messages .dup-notifications-message.current {
display: block;
}
#dup-notifications .dup-notifications-messages .dup-notifications-title {
color: #444444;
font-size: 17px;
font-weight: 600;
line-height: 17px;
margin: 0 0 -2px 0;
min-height: 19px;
}
#dup-notifications .dup-notifications-messages .dup-notifications-content {
font-weight: normal;
font-size: 14px;
line-height: 18px;
margin: 8px 0 20px 0;
color: #777777;
}
#dup-notifications .dup-notifications-messages .dup-notifications-content p {
font-size: inherit;
line-height: inherit;
margin: 0 0 5px;
}
#dup-notifications .dup-notifications-messages .dup-notifications-buttons {
margin: -30px 80px 0 0;
}
#dup-notifications .dup-notifications-messages .dup-notifications-buttons a {
margin: 0 10px 0 0;
min-height: unset;
}
#dup-notifications .dup-notifications-badge {
background-color: #f6f7f7;
border-radius: 3px;
color: #2c3338;
cursor: pointer;
font-size: 11px;
margin-left: 10px;
padding: 6px 8px;
position: relative;
text-decoration: none;
text-transform: uppercase;
top: -1px;
white-space: nowrap;
}
#dup-notifications .dup-notifications-badge:focus, #dup-notifications .dup-notifications-badge:hover {
background-color: #f0f0f1;
box-shadow: none;
color: initial;
}
#dup-notifications .dup-notifications-badge .fa {
color: black;
padding-right: 6px;
position: relative;
}
#dup-notifications .dismiss {
position: absolute;
top: 15px;
right: 16px;
width: 16px;
height: 16px;
color: #a7aaad;
font-size: 16px;
cursor: pointer;
text-align: center;
vertical-align: middle;
line-height: 16px;
}
#dup-notifications .dismiss:hover {
color: #dc3232;
}
#dup-notifications .navigation {
position: absolute;
bottom: 20px;
right: 16px;
width: 63px;
height: 30px;
}
#dup-notifications .navigation a {
display: block;
width: 30px;
height: 30px;
border: 1px solid #7e8993;
border-radius: 3px;
font-size: 16px;
line-height: 1.625;
text-align: center;
cursor: pointer;
background-color: #ffffff;
color: #41454a;
}
#dup-notifications .navigation a:hover {
background-color: #f1f1f1;
}
#dup-notifications .navigation .prev {
float: left;
}
#dup-notifications .navigation .next {
float: right;
}
#dup-notifications .navigation .disabled {
border-color: #dddddd;
color: #a0a5aa;
cursor: default;
}
#dup-notifications .navigation .disabled:hover {
background-color: #ffffff;
}
.dup-notifications-message .button {
margin: 0 10px 0 0;
}
.lity-iframe .lity-content {
margin: 0 auto;
}
@media screen and (max-width: 768px) {
#dup-notifications .dup-notifications-messages {
padding: 15px 50px 20px 16px;
}
#dup-notifications .dup-notifications-messages .dup-notifications-message .dup-notifications-title {
line-height: 22px;
margin: 0 30px -2px 0;
min-height: 24px;
}
#dup-notifications .dup-notifications-messages .dup-notifications-message .dup-notifications-content {
font-size: 16px;
line-height: 22px;
}
#dup-notifications .dup-notifications-messages .dup-notifications-message .dup-notifications-buttons {
margin: -30px 80px 0 0;
}
#dup-notifications .dup-notifications-messages .dup-notifications-message .dup-notifications-buttons a {
margin: 0;
display: table;
}
#dup-notifications .dup-notifications-messages .dup-notifications-message .dup-notifications-buttons .button-secondary {
margin-top: 6px;
}
}

9
wp-content/plugins/duplicator-pro-v4.5.16.2/assets/css/font-awesome/css/all.min.css vendored Normal file
View File

File diff suppressed because one or more lines are too long

3
wp-content/plugins/duplicator-pro-v4.5.16.2/assets/css/font-awesome/css/index.php Normal file
View File

@@ -0,0 +1,3 @@
<?php
//silent

3
wp-content/plugins/duplicator-pro-v4.5.16.2/assets/css/font-awesome/index.php Normal file
View File

@@ -0,0 +1,3 @@
<?php
//silent

BIN
wp-content/plugins/duplicator-pro-v4.5.16.2/assets/css/font-awesome/webfonts/fa-brands-400.ttf Normal file
View File

Binary file not shown.

BIN
wp-content/plugins/duplicator-pro-v4.5.16.2/assets/css/font-awesome/webfonts/fa-brands-400.woff2 Normal file
View File

Binary file not shown.

BIN
wp-content/plugins/duplicator-pro-v4.5.16.2/assets/css/font-awesome/webfonts/fa-regular-400.ttf Normal file
View File

Binary file not shown.

BIN
wp-content/plugins/duplicator-pro-v4.5.16.2/assets/css/font-awesome/webfonts/fa-regular-400.woff2 Normal file
View File

Binary file not shown.

BIN
wp-content/plugins/duplicator-pro-v4.5.16.2/assets/css/font-awesome/webfonts/fa-solid-900.ttf Normal file
View File

Binary file not shown.

BIN
wp-content/plugins/duplicator-pro-v4.5.16.2/assets/css/font-awesome/webfonts/fa-solid-900.woff2 Normal file
View File

Binary file not shown.

BIN
wp-content/plugins/duplicator-pro-v4.5.16.2/assets/css/font-awesome/webfonts/fa-v4compatibility.ttf Normal file
View File

Binary file not shown.

BIN
wp-content/plugins/duplicator-pro-v4.5.16.2/assets/css/font-awesome/webfonts/fa-v4compatibility.woff2 Normal file
View File

Binary file not shown.

3
wp-content/plugins/duplicator-pro-v4.5.16.2/assets/css/font-awesome/webfonts/index.php Normal file
View File

@@ -0,0 +1,3 @@
<?php
//silent

130
wp-content/plugins/duplicator-pro-v4.5.16.2/assets/css/global_admin_style.css Normal file
View File

@@ -0,0 +1,130 @@
/* ================================================
* DUPLICATOR STYLE
* Included in all admin pages
* ================================================ */
ul.dup-pro-simple-style-disc {
list-style: disc;
margin-left: 20px;
}
ul.dup-pro-simple-style-list {
margin: 0;
}
ul.dup-pro-simple-style-list li {
margin-bottom: 2px;
}
ul.dup-pro-simple-style-list li:last-child {
margin: 0;
}
ul.dup-pro-simple-style-list li::before {
content: "-";
margin: 0 5px;
}
.dup-dashboard-widget-content .maroon {
color: maroon;
}
.dup-dashboard-widget-content .green {
color: #00a32a;
}
.dup-dashboard-widget-content .gary {
color: #646970;
}
.dup-dashboard-widget-content a.disabled {
pointer-events: none;
cursor: default;
}
.dup-dashboard-widget-content .separator {
margin: 1em 0;
}
.dup-dashboard-widget-content .dup-packages-counts {
text-align: right;
}
.dup-dashboard-widget-content .dup-section-last-packages ul,
.dup-dashboard-widget-content .dup-section-sections ul {
list-style: none;
padding: 0;
margin: 0;
}
.dup-dashboard-widget-content .dup-section-last-packages ul li,
.dup-dashboard-widget-content .dup-section-sections ul li {
margin: 0 0 10px 0;
}
.dup-dashboard-widget-content .dup-section-last-packages ul li:last-child,
.dup-dashboard-widget-content .dup-section-sections ul li:last-child {
margin: 0;
}
.dup-dashboard-widget-content .dup-section-label-fixed-width {
display: inline-block;
min-width: 120px;
}
.dup-dashboard-widget-content .dup-section-sections .dashicons {
margin-right: 5px;
}
.dup-dashboard-widget-content .dup-section-sections .dashicons-image-rotate {
font-size: 16px;
}
.dup-dashboard-widget-content .spinner {
float: none;
visibility: visible;
margin: 0;
}
.dup-dashboard-widget-content .dup-section-recommended {
line-height: 20px;
}
.dup-dashboard-widget-content .dup-section-recommended .action-links a:after {
content: "|";
cursor: not-allowed;
margin: 0 5px;
color: #646970;
}
.dup-dashboard-widget-content .dup-section-recommended .action-links a:last-child:after {
content: "";
margin: 0;
}
.dup-dashboard-widget-content .dup-recommended-label {
color: #787c82;
}
.dup-dashboard-widget-content #dup-dash-widget-section-recommended {
margin: 0;
padding: 0;
border: 0 none;
background: transparent;
color: #787c82;
cursor: pointer;
}
.dup-dashboard-widget-content .dup-flex-content {
display: flex;
justify-content: space-between;
align-items: center;
}
.dup-dashboard-widget-content .dup-flex-content > * {
padding-right: 5px;
}
.dup-dashboard-widget-content .dup-flex-content > *:last-child {
padding-right: 0;
}

3
wp-content/plugins/duplicator-pro-v4.5.16.2/assets/css/images/index.php Normal file
View File

@@ -0,0 +1,3 @@
<?php
//silent

BIN
wp-content/plugins/duplicator-pro-v4.5.16.2/assets/css/images/ui-bg_flat_0_aaaaaa_40x100.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 180 B

BIN
wp-content/plugins/duplicator-pro-v4.5.16.2/assets/css/images/ui-bg_flat_75_ffffff_40x100.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 178 B

BIN
wp-content/plugins/duplicator-pro-v4.5.16.2/assets/css/images/ui-bg_glass_55_fbf9ee_1x400.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 120 B

BIN
wp-content/plugins/duplicator-pro-v4.5.16.2/assets/css/images/ui-bg_glass_65_ffffff_1x400.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 105 B

BIN
wp-content/plugins/duplicator-pro-v4.5.16.2/assets/css/images/ui-bg_glass_75_dadada_1x400.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 111 B

BIN
wp-content/plugins/duplicator-pro-v4.5.16.2/assets/css/images/ui-bg_glass_75_e6e6e6_1x400.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 110 B

BIN
wp-content/plugins/duplicator-pro-v4.5.16.2/assets/css/images/ui-bg_glass_95_fef1ec_1x400.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 149 B

BIN
wp-content/plugins/duplicator-pro-v4.5.16.2/assets/css/images/ui-bg_highlight-soft_75_cccccc_1x100.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 101 B

BIN
wp-content/plugins/duplicator-pro-v4.5.16.2/assets/css/images/ui-icons_222222_256x240.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 4.3 KiB

BIN
wp-content/plugins/duplicator-pro-v4.5.16.2/assets/css/images/ui-icons_2e83ff_256x240.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 5.2 KiB

BIN
wp-content/plugins/duplicator-pro-v4.5.16.2/assets/css/images/ui-icons_454545_256x240.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 4.3 KiB

BIN
wp-content/plugins/duplicator-pro-v4.5.16.2/assets/css/images/ui-icons_888888_256x240.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 4.3 KiB

BIN
wp-content/plugins/duplicator-pro-v4.5.16.2/assets/css/images/ui-icons_cd0a0a_256x240.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 4.3 KiB

608
wp-content/plugins/duplicator-pro-v4.5.16.2/assets/css/import.css vendored Normal file
View File

@@ -0,0 +1,608 @@
/*! ================================================
* DUPLICATOR IMPORT STYLE
* Copyright:Snap Creek LLC 2015-2021
* ================================================ */
/* ======================================================================================================================
COMMON/SHARED DOM ELEMENTS
====================================================================================================================== */
.dup-pro-import-header {
position: relative;
margin-bottom: 20px;
margin-top: 10px;
}
.dup-pro-import-header .title {
margin: 0;
line-height: 40px;
font-size:20px;
}
.dup-pro-import-header .options {
position: absolute;
right: 0;
top: 2px;
z-index: 10000;
}
.dup-pro-import-header hr {
margin: 0;
}
.dup-pro-import-header .options .button {
width: 34px;
height: 34px;
box-sizing: border-box;
line-height: 34px;
text-align: center;
padding: 0;
}
/* ======================================================================================================================
STEP 1 - DOM ELEMENTS
====================================================================================================================== */
/* -----------------------------
MENU - DROP-DOWN HAMBURGER
----------------------------- */
.dup-pro-import-view-list,
.dup-pro-import-view-single {
position: relative;
}
.dup-pro-import-view-list.active::before,
.dup-pro-import-view-single.active::before {
content: "\f147";
font-family: dashicons;
display: inline-block;
line-height: 1;
font-weight: 400;
font-style: normal;
width: 20px;
height: 20px;
font-size: 20px;
position: absolute;
top: 50%;
left: -30px;
}
.dup-pro-toggle-sub-menu,
.dup-pro-toggle-sub-menu ul,
.dup-pro-toggle-sub-menu li {
margin: 0;
}
.dup-pro-toggle-sub-menu .title {
color: #666666;
font-weight: bold;
}
.dup-pro-toggle-sub-menu .separator {
border-top: 1px solid #ccd0d4;
}
.dup-pro-toggle-sub-menu .dup-pro-toggle {
display: inline-block;
width: 100%;
box-sizing: border-box;
text-align: right;
}
.dup-pro-toggle-sub-menu ul {
display: none;
position: relative;
opacity: 0;
border: 1px solid #ccd0d4;
z-index: -1;
background: #FEFEFE;
transition: opacity 0.3s;
padding-bottom: 20px;
}
.dup-pro-toggle-sub-menu:hover ul {
display: block;
opacity: 1;
z-index: 10001;
}
.dup-pro-toggle-sub-menu ul li {
padding: 10px 10px 10px 40px;
}
.dup-pro-toggle-sub-menu ul li.title {
padding: 10px 10px 0 10px;
}
#dup-pro-import-vews-and-opt-wrapper .description {
display: block;
color: #666666;
font-style: italic;
}
#dup-pro-import-vews-and-opt-wrapper {
width: 250px;
}
/* -----------------------------
DRAG-DROP UPLOAD AREA
----------------------------- */
.dup-pro-import-upload-box {
background: #fff;
border: 3px dashed #607d8b;
border-radius: 2px;
height: 220px;
box-sizing: border-box;
position: relative;
text-align: center;
font-size: 14px;
}
#dup-pro-import-upload-file .fs-upload-target {
border: 0 none;
border-radius: 0;
height: 214px;
box-sizing: border-box;
}
#dup-pro-import-upload-file .fs-upload-target {
display: flex;
align-items: center;
justify-content: center;
}
#dup-pro-import-upload-file-footer {
padding: 5px;
text-align: right;
}
#dup-pro-import-upload-file-footer .dup-pro-open-help-link {
letter-spacing: 2px;
float: right;
}
/* -----------------------------
ARCHIVE DISPLAY RESULTS:
Basic/Advanced
----------------------------- */
.dup-drag-drop-message {
font-size: 18px;
font-weight: bold;
display: block;
margin: 20px 0;
}
#dup-pro-import-mode-tab-header {
border-bottom: 1px solid silver;
}
#dup-pro-import-mode-tab-header > div {
float: left;
padding:10px 0 15px 0;
font-size: 16px;
border-bottom: 2px solid transparent;
min-width: 250px;
text-align: center;
cursor: pointer;
}
#dup-pro-import-mode-tab-header > div:hover {
font-weight: bold;
}
#dup-pro-import-mode-tab-header > div.active {
border-bottom: 3px solid #91BCE3;
font-weight: bold;
}
#dup-pro-import-remote-url {
box-sizing: border-box;
height: 40px;
width: 1000px;
max-width: calc(100% - 150px);
margin-right: 10px;
}
.dup-pro-import-upload-box > div {
width: 100%;
}
.dup-pro-import-upload-box .dup-import-button {
display: inline-block;
padding: 0 30px !important;
font-weight: normal;
box-sizing: border-box;
height: 40px;
}
#dup-pro-import-mode-remote-tab sup {
font-size:10px;
color:#999;
}
div.dup-pro-import-upload-box small {
color:#999;
font-style: italic;
padding: 7px;
}
.dup-import-avail-packs .dup-pro-import-no-package-found td {
padding: 20px;
}
div.dup-pro-import-no-package-found-msg {
font-size: 15px;
text-align: center;
}
table.dup-import-avail-packs th {
background-color: #e2e2e2;
}
table.dup-import-avail-packs tbody tr:nth-child(even) {
border: 1px solid #e2e2e2;
}
table.dup-import-avail-packs {
width: 100%;
min-height: inherit;
border: 1px solid #ccd0d4;
border-collapse: collapse;
}
table.dup-import-avail-packs thead {
border-bottom: 1px solid #ccd0d4;
}
table.dup-import-avail-packs th {
font-weight: bold;
}
table.dup-import-avail-packs th,
table.dup-import-avail-packs td {
padding: 10px;
text-align: left;
vertical-align: top;
line-height: 30px;
}
table.dup-import-avail-packs .size {
width: 100px;
}
table.dup-import-avail-packs .created {
text-align: left;
width: 125px;
}
table.dup-import-avail-packs .funcs {
text-align: center;
width: 400px;
box-sizing: border-box;
white-space: nowrap;
}
table.dup-import-avail-packs .funcs button,
table.dup-import-avail-packs .funcs .button {
min-width: 120px;
}
table.dup-import-avail-packs .funcs .separator {
margin-left: 5px;
}
table.dup-import-avail-packs .funcs .separator-2x {
margin-left: 10px;
}
table.dup-import-avail-packs .funcs .dup-pro-loader {
display: flex;
}
table.dup-import-avail-packs .funcs div.actions {
text-align: right;
}
table.dup-import-avail-packs .funcs .dup-pro-import-action-cancel-upload {
margin-left: 10px;
}
.dup-pro-import-package-detail {
padding: 10px;
border-radius: 2px;
margin: 10px 0;
line-height: 1.6;
}
.dup-pro-import-package-detail-content *:first-child {
margin-top: 0;
}
.dup-pro-import-package-detail-content *:last-child {
margin-bottom: 0;
}
.dup-pro-import-package-detail ul {
margin: 0;
}
.dup-pro-import-package-detail ul li {
margin: 2px;
padding: 0;
}
.dup-pro-import-package-detail .label.title {
font-weight: bold;
font-size: 16px;
width: 100%;
margin-top: 10px;
}
.dup-pro-import-package-detail .label {
display: inline-block;
min-width: 150px;
}
.dup-pro-import-package-detail .value {
font-weight: bold;
}
div#dpro-pro-import-available-packages {
background-color: #fff;
}
#dpro-pro-import-available-packages.view-single-item .packages-list tbody {
display: block;
padding: 20px;
}
#dpro-pro-import-available-packages.view-single-item .packages-list thead,
#dpro-pro-import-available-packages.view-single-item .packages-list tbody tr {
display: none;
}
#dpro-pro-import-available-packages.view-single-item .packages-list tbody tr:first-child {
display: block;
}
#dpro-pro-import-available-packages.view-single-item .packages-list td {
display: block;
width: 100%;
padding: 0;
}
#dpro-pro-import-available-packages.view-single-item .packages-list .dup-pro-import-package-detail {
display: block !important;
background: transparent;
margin: 0;
padding: 0;
}
#dpro-pro-import-available-packages.view-single-item .packages-list .name::before {
content: "Package: ";
font-weight: bold;
margin: 0 5px 10px 0;
display: inline-block;
}
#dpro-pro-import-available-packages.view-single-item .packages-list .size,
#dpro-pro-import-available-packages.view-single-item .packages-list .created,
#dpro-pro-import-available-packages.view-single-item .packages-list .dup-pro-import-action-package-detail-toggle {
display: none;
}
@media only screen and (max-width: 1200px) {
#dpro-pro-import-available-packages.view-list-item .size,
#dpro-pro-import-available-packages.view-list-item .created,
#dpro-pro-import-available-packages.view-list-item thead .funcs {
display: none;
}
#dpro-pro-import-available-packages.view-list-item td {
display: block;
text-align: left !important;
padding: 0 20px;
}
#dpro-pro-import-available-packages.view-list-item tbody tr {
border-bottom: 1px solid #ccd0d4;
padding-bottom: 10px;
display: block;
}
}
.dup-pro-import-confirm-buttons {
padding: 10px;
text-align: right;
}
.dup-pro-import-confirm-buttons input {
margin-left: 5px !important;
}
/* ======================================================================================================================
STEP 2 - DOM ELEMENTS
======================================================================================================================*/
.dup-pro-import-box {
background-color: #fff;
border: 1px solid #e5e5e5;
margin: 0;
}
.dup-pro-import-box .box-title {
border-bottom: 1px solid #e5e5e5;
padding: 10px 12px;
font-weight: bold;
font-size: 17px;
font-weight: bold;
color: #000;
}
.dup-pro-import-box .box-content {
padding: 20px;
}
.dup-pro-import-box.closable .box-title {
position: relative;
}
.dup-pro-import-box.closable .box-title::after {
content: "";
position: absolute;
top: 0;
right: 0;
line-height: 36px;
display: inline-block;
width: 36px;
text-align: center;
font-family: "Font Awesome 5 Free";
content: "";
font-weight: 900;
}
.dup-pro-import-box.closable.closed .box-title {
border: 0 none;
}
.dup-pro-import-box.closable.closed .box-title::after {
content: "\f0d7";
}
.dup-pro-import-box.closable.opened .box-title::after {
content: "\f0d8";
}
.dup-pro-import-box.closable.closed .box-content {
display: none;
}
.dup-pro-import-box.closable.opened .box-content {
display: block;
}
#dup-pro-import-view-types {
position: absolute;
top: -5px;
right: 0;
}
div.dup-pro-recovery-point-selector .dup-pro-notice {
margin: 0;
font-size: 16px;
}
div.dup-pro-recovery-point-selector div.dup-pro-notice-details {
margin: 20px;
font-size: 16px;
font-style: italic;
}
/* ======================================================================================================================
STEP 3 - STAND-ALONE INSTALLER DOM ELEMENTS
======================================================================================================================*/
#dup-pro-import-installer-modal {
position: fixed;
top: 0;
left: 0;
width: 100vw;
height: 100vh;
z-index: 2;
background-color: rgba(255, 255, 255, .6);
z-index: 1000002;
}
#dpro-pro-import-installer-iframe {
width: 100%;
min-height: 300px;
position: relative;
z-index: 1000003;
}
/* Making sure the WP menu is not under the import screen */
#wpadminbar,
#wpadminbar .ab-sub-wrapper,
#wpadminbar ul,
#wpadminbar ul li {
z-index: 1000004;
}
.dup-pro-import-installer-launch-confirm-content,
.dup-pro-import-installer-launch-confirm-content p {
font-size: 13px;
}
.dup-pro-import-installer-launch-confirm-content .dup-pro-notice {
font-color: #666;
font-style: italic;
}
.dup-pro-import-installer-launch-confirm-content .dup-pro-recovery-info-set {
border: 1px solid lightgray;
padding: 5px;
border-radius: 5px;
background: #FAFAFA;
}
.dup-pro-import-installer-launch-confirm-content .dup-pro-recovery-info-set .dup-pro-selector-wrapper {
text-align: right;
}
.dup-pro-import-installer-launch-confirm-content .dup-pro-recovery-info-set select {
margin: 0 0 5px 0;
}
.admin_page_duplicator-pro-import-installer .wpcontent {
position: relative;
}
.admin_page_duplicator-pro-import-installer #wpfooter {
display: none;
}
.admin_page_duplicator-pro-import-installer:not(.dup-actions-error) #wpbody-content>* {
display: none;
}
#dpro-pro-import-installer-wrapper {
position: absolute;
top: 0;
left: 0;
width: 100%;
display: flex !important;
flex-flow: column;
z-index: 1000000;
}
.admin_page_duplicator-pro-import-installer #adminmenuwrap,
#dpro-pro-import-installer-wrapper {
height: calc(100vh - 32px);
overflow: hidden;
}
@media only screen and (max-width: 782px) {
.admin_page_duplicator-pro-import-installer #adminmenuwrap,
#dpro-pro-import-installer-wrapper {
height: calc(100vh - 46px);
}
}
#dpro-pro-import-installer-iframe {
flex: 1 1 auto;
}
#dpro-pro-import-installer-top-bar {
padding: 20px 0;
}

3
wp-content/plugins/duplicator-pro-v4.5.16.2/assets/css/index.php Normal file
View File

@@ -0,0 +1,3 @@
<?php
//silent

7
wp-content/plugins/duplicator-pro-v4.5.16.2/assets/css/jquery-ui.css vendored Normal file
View File

File diff suppressed because one or more lines are too long

803
wp-content/plugins/duplicator-pro-v4.5.16.2/assets/css/packages.css Normal file
View File

@@ -0,0 +1,803 @@
/*! ================================================
* DUPLICATOR PACKAGE STYLE
* Copyright:Snap Creek LLC 2015-2021
* ============================================== */
/* ================================================
* COMMON:GENERAL CLASSES
* ============================================= */
.margin-b-10px {margin-bottom: 10px;}
.margin-b-20px {margin-bottom: 20px;}
.margin-b-40px {margin-bottom: 40px;}
.font-silver {color:silver !important}
.font-gray {color:gray !important}
.font-black {color:black !important}
.disabled {color:gray;}
.color-alert {color:#dc3232 !important;}
.dup-cursor-pointer {cursor:pointer;}
.no-outline {outline: none !important; box-shadow: none !important;}
a.disabled:hover {
color:gray !important;
background:#e0e0e0 !important;
}
input#dup-chk-all {
margin:0; padding:0 0 0 5px;
}
.dup-data-badge {
position:relative;
}
.dup-data-badge[data-badge]:after {
content:attr(data-badge);
position:absolute;
top:-7px;
right:-7px;
font-size:.75em;
background:#d63638;
color:white;
width:16px;
height:16px;
text-align:center;
line-height:16px;
border-radius:50%;
box-shadow:0 0 1px #333;
}
div.dup-pack-status-info {
float:left;
font-style:italic;
font-size:11px;
}
/* ================================================
* COMMON:Build Progress & Misc
* ============================================= */
div.dup-build-msg {
padding:30px 20px 30px 20px;
border:1px solid #e8e8e8;
border-radius: 2px;
margin:0 0 0 0;
text-align:center;
font-size:14px;
line-height:20px;
}
div.dup-build-msg button {
display:block;
margin-top:10px !important;
font-weight:bold;
}
div.dup-build-msg div.status-hdr {
font-size:18px;
font-weight:bold
}
button.dup-build-stop-btn {
width:150px !important
}
table.dup-packtbl div#dup-progress-bar-area {
width:300px;
margin:5px auto 0 auto;
border:none;
box-shadow:none;
padding:0 0 10px 0;
}
.dup-row-complete td div.progress-error {
font-size:13px;
color:#555;
}
div.dup-quick-start {
font-style:italic;
font-size:13px;
line-height:18px;
margin-top:15px;
line-height: 23px;
}
div.dup-paged-nav {
text-align:right
}
/* ================================================
* PACK-MAIN-TABLE:Common
* ============================================= */
table.dup-packtbl tr {
border-bottom:1px solid #e8e8e8;
color:#000;
}
table.dup-packtbl td {
color:#000;
}
table.dup-packtbl td.dup-list-nopackages {
text-align:center; padding:50px 0 80px 0; font-size:20px
}
table.dup-packtbl {
word-break:break-all;
}
table.dup-packtbl tfoot th {
font-size:12px
}
table.dup-packtbl th {
white-space:nowrap !important;
}
table.dup-packtbl input[name="delete_confirm"] {
margin-left:15px
}
table.dup-packtbl {
border-collapse:collapse
}
table.dup-packtbl td {
text-overflow: ellipsis;
}
table.dup-packtbl tr:last-child {
border:none
}
#dup-header-chkall {
padding: 0;
width:30px;
}
#dup-header-chkall a {
display: block;
text-align: center;
}
th#dup-header-chkall:hover {
border-left: 1px solid #e8e8e8;
background-color:#EDEFEF;
}
th#dup-header-chkall a:focus {
outline: none !important;
box-shadow: none !important;
}
.dup-status-icons-list .icon-wrapper {
margin-right: 5px;
min-width: 15px;
display: inline-block;
}
.dup-packtbl .dup-note-column {
width: 150px;
}
.dup-packtbl .dup-storages-column {
display: none; /* future use */
width: 150px;
}
.dup-packtbl .dup-flags-column {
width: 80px;
}
.dup-packtbl .dup-created-column {
width: 100px;
}
.dup-packtbl .dup-age-column {
width: 50px;
}
.dup-packtbl .dup-size-column {
width: 80px;
}
/* ================================================
* PACK-TABLE-ROW:Visible Row Styles
* ============================================= */
tr.dup-row-alt-light {
background-color:#fff !important;
}
tr.dup-row-alt-dark {
background-color:#F6F7F7 !important;
}
tr.dup-row-incomplete td:last-child {
text-align:center;
}
tr.dup-row-complete td,
tr.dup-row-incomplete td {
white-space:nowrap;
vertical-align:middle;
}
tr.dup-row-complete td sup {
font-size:11px;
vertical-align:baseline;
position:relative;
top:-0.6em;
font-style:italic;
}
tr.dup-row-building td {
color:#6b956d !important;
}
/* --------------------
BUTTONS: Cell Areas */
.dup-cell-err-btn,
td.dup-cell-btns,
td.dup-cell-err
{
text-align:center;
white-space:nowrap;
background:linear-gradient(180deg, rgba(255,255,255,1) 16%, rgba(246,247,247,1) 51%, rgba(246,247,247,1) 100%);
border:1px solid #e8e8e8;
border-bottom:none !important;
border-right:none !important;
}
.progress-error .button,
.dup-cell-btns .button {
line-height: 50px;
}
td.dup-cell-err:hover,
td.dup-cell-btns:hover{
background:#EDEFEF;
cursor:pointer;
}
.dup-recovery-package .dup-name-column {
color: #008000;
font-weight: bold;
}
.dup-package-flags {
font-size: 15px;
color: #333;
}
.dup-package-flags .icon-wrapper {
margin-right: 8px;
}
.dup-package-flags .icon-wrapper:last-child {
margin-right: 0;
}
td.dup-cell-chk {
padding:0 !important;
}
td.dup-cell-chk label {
width:55px;
height:30px;
display:inline-block;
padding:10px 0 0 10px;
}
td.dup-cell-chk label input {
display:inline-block;
}
td.dup-cell-cancelled {
color:#a3a3a3 !important;
}
.dup-dnload-btn-single {
width:50%;
height:50px;
text-align: center !important;
}
.dup-dnload-btn-single:first-child {
border-right: 1px solid #e8e8e8 !important;
}
/* --------------------
BUTTON: Error */
.dup-cell-err-btn {
text-decoration:none !important;
padding:2px 20px 2px 20px;
width:100%;
border:none !important;
background-color: transparent !important;
}
a.dup-cell-err-btn:hover i,
a.dup-cell-err-btn:hover {
background-color: transparent !important;
}
a.dup-cell-err-btn:hover {
text-decoration: underline;
}
/* ================================================
* PACK-TABLE-CELL: Download/Store/Toggle Buttons
* ============================================= */
tr:last-child td.dup-cell-btns {
border-bottom:none
}
.dup-cell-err-btn,
td.dup-cell-incomplete,
td.dup-cell-cancelled,
td.dup-cell-btns button,
td.dup-cell-btns .button {
height:50px;
}
td.dup-cell-incomplete,
td.dup-cell-cancelled {
padding: 0;
}
td.dup-cell-btns button,
td.dup-cell-btns .button {
border:none !important;
background-color:transparent !important;
width:100%;
min-width:115px;
border-radius:0 !important;
text-align: center;
}
td.dup-cell-btns a,
td.dup-cell-btns a:focus {
outline: none !important;
box-shadow: none !important;
background: transparent !important;
}
td.dup-cell-btns button:focus,
td.dup-cell-btns a:focus {
border:none !important; box-shadow:none !important
}
td.dup-cell-btns {
cursor:pointer; padding:0; margin:0
}
td.dup-cell-btns button.disabled,
td.dup-cell-btns a.disabled {
background:transparent !important
}
/* --------------------
DOWNLOAD BUTTONS */
nav.dup-dnload-menu {
display:inline-block;
width:100%
}
nav.dup-dnload-menu-items {
display:none;
position:absolute;
z-index:1000;
padding:7px;
border:1px solid #C4C4C4;
background-color:#fff;
min-width:125px;
}
nav.dup-dnload-menu-items button {
padding:2px 2px 2px 8px;
border-color:transparent;
background:transparent;
display:block;
width:100%;
box-sizing:border-box;
text-align:left;
line-height:32px;
height:40px !important;
}
nav.dup-dnload-menu-items button:hover {
background:#efefef !important;
cursor:pointer;
text-decoration:none !important;
}
nav.dup-dnload-menu button span i.fa,
nav.dup-dnload-menu button span i.fas,
nav.dup-dnload-menu button span i.far {
display:inline-block; width:18px;
}
button.dup-dnload-btn{
text-align: center !important;
}
div.dup-dnload-btn-disabled {
padding:15px 10px 15px 10px;
width:95px;
color:#999;
}
/* --------------------
STOREAGE & TOGGLE BUTTONS */
td.dup-cell-store-btn,
td.dup-cell-toggle-btn {
width:80px;
}
td.dup-cell-toggle-btn a.button-link {
padding-top:3px;
}
td.dup-cell-toggle-btn {
text-align:center;
border-right:none !important
}
td.dup-cell-store-btn.disabled {
color:silver;
}
td.dup-cell-btns.dup-cell-store-btn.disabled:hover {
background:linear-gradient(180deg, rgba(255,255,255,1) 16%, rgba(246,247,247,1) 51%, rgba(246,247,247,1) 100%);
}
.remote-data-fail {
position:relative;
}
.remote-data-fail:after {
content:attr(data-badge);
position:absolute;
top:-5px;
right:-8px;
font-size:.5em;
background:#ca4a1f;
width:7px;
height:7px;
border-radius:50%;
}
/* ================================================
* PACKAGE-OVERVIEW-AREA
* ============================================= */
div.dup-ovr-hdr {
padding:0 0 10px 7px;
font-size: 18px;
color:#000;
width:100%;
font-weight: bold;
}
div.dup-ovr-hdr i.fa-question-circle {
color:#d9d9d9;
}
div.dup-wp-back-logo {
position: relative;
border:0 solid red;
margin:25px 0;
}
div.dup-wp-back-logo div {
position: absolute;
top:3px;
right:4px;
color:#eee;
font-size:40px
}
.dup-row-details {
border-top:none;
display:none;
background-color:#fff !important
}
.dup-row-details > td {
padding: 0;
}
.dup-row-details .dup-package-row-details-wrapper {
border-left: 3px solid #444444;
padding: 20px;
}
.dup-row-details td:hover {
background-color:#ffffff !important
}
/* --------------------
BAR INFO SECTION*/
div.dup-ovr-bar-flex-box > div {
min-width:95px;
padding:5px 5px 5px 15px;
}
div.dup-ovr-bar-flex-box label {
font-weight:bold
}
div.dup-ovr-bar-flex-box {
display:flex;
background-color:#F6F7F7;
height:50px;
border:1px solid #e8e8e8;
background:linear-gradient(180deg, hsla(180, 6%, 97%, 1) 60%, hsla(0, 0%, 100%, 1) 100%);
}
div.dup-ovr-bar-flex-box div.divider {
border-right: 1px solid #e8e8e8;
}
/* --------------------
OVERVIEW CTRL-AREA */
.dup-ovr-ctrls-flex-box {
display:flex;
flex-wrap:wrap;
flex-direction:row;
justify-content: start;
gap: 20px;
margin-top: 20px;
}
.dup-ovr-ctrls-flex-box .flex-item .dup-ovr-ctrls-hdrs {
border-bottom:1px solid #dfdfdf;
padding:0 0 5px 0
}
.dup-ovr-ctrls-flex-box .flex-item:first-child {
flex: 5 0 auto;
font-size:15px;
}
.dup-ovr-ctrls-flex-box .flex-item:last-child {
flex: 0 0 350px;
}
.flex-item > div {
padding:2px;
font-size:15px;
white-space:nowrap;
}
.flex-item > .dup-ovr-ctrls-hdrs {
font-size:18px;
margin:5px 0 10px 0;
height:40px;
}
/* --------------------
INSTALL RESOURCES*/
.dup-ovr-copy-flex-box {
display: flex;
flex-wrap: wrap;
flex-flow: row;
padding:5px;
}
.dup-ovr-copy-flex-box .flex-item:nth-of-type(1) {
flex:2 0 auto;
padding: 0;
}
.dup-ovr-copy-flex-box .flex-item:nth-of-type(2) {
flex:0 0 225px;
padding:0;
}
input.dup-ovr-ref-links {
width:100%;
text-overflow:ellipsis;
font-size:12px;
border:1px solid silver;
border-radius:0;
padding-right:25px;
}
.dup-ovr-ref-links-icon {
float: right;
margin:-22px 6px 0 0 ;
position: relative;
z-index: 2;
color: #b2b2b2;
cursor:help;
}
.dup-ovr-ctrls-flex-box sup .fa-question-circle {
padding-left:3px;
}
input.dup-ovr-ref-links.missing {
color:maroon;
}
.dup-ovr-ref-links-more {
font-size:13px;
display:block;
text-align:right;
float:right;
padding:5px 0 0 0 ;
cursor: pointer;
}
.dup-ovr-ref-copy,
.dup-ovr-ref-dwnld {
padding:5px 10px 5px 10px;
margin:-1px 0 0 7px;
border:1px solid silver;
display:inline-block;
cursor:pointer;
border-radius:2px;
min-width:85px;
text-align: center;
font-size:13px;
}
span.dup-ovr-ref-dwnld:hover {
background-color: #F0F0F0;
}
span.dup-ovr-ref-copy:hover {
border:1px solid #dcdcdc;
background-color:#f0f0f0
}
span.dup-info-msg01 {
font-size:11px;
color:gray;
font-weight:normal;
font-style:italic;
display:inline-block
}
/* --------------------
OPTIONS SECTION*/
div.dup-ovr-opts .button {
font-size:14px;
display: block;
text-align: center;
margin:10px 0 10px 0;
padding:1px 20px 3px 20px;
border:1px solid #dcdcdc;
min-width:175px;
height: 40px;
line-height: 40px;
border-radius:2px;
width: 100%;
max-width: 250px;
}
div.dup-ovr-opts .button:hover {
background-color:#f0f0f0
}
/* ================================================
* TUTORIAL DIALOG
* ============================================= */
div.dup-dlg-links-subtxt {
color:#777;
padding:0;
margin-top:-5px;
font-size:12px;
font-style: italic;
}
/* --------------------
SPINNER SECTION*/
div.dup-spin-hlp h3 {
color:#333;
font-size:24px;
margin:0 0 2px 0;
padding:5px 0 3px 0;
border-bottom: 1px solid silver;
}
div.dup-spin-hlp {
font-size:16px;
user-select:none;
}
div.dup-spin-hlp b {
font-weight: 700;
}
div.dup-spin-hlp i.fa-question-circle {
vertical-align: top;
color:#999;
font-size:11px;
}
div.dup-spin-hlp small {
color:#999;
font-style: italic;
font-weight: normal;
}
div.dup-spin-hlp > div.title {
font-size:18px;
font-weight: bold;
}
div.dup-spin-hlp div.sub-head {
color:darkgreen;
font-size:0.85em;
font-style: italic;
margin:0 0 15px 0;
}
div.dup-spin-hlp small.grey {
color:#777;
}
div.dup-spin-hlp ul.sub-list {
padding: 7px;
}
div.dup-ovr-continue {
display: block;
width: 100%;
text-align: right;
font-size:18px;
}
div.dup-tabvert-hlp > div.panel > div.title {
font-size:18px;
font-weight: bold;
border-bottom: 1px solid silver;
padding: 2px 0 2px 0;
margin:0 0 5px 0;
}
/* ================================================
* RECOVERY POINT DIALOG
* ============================================= */
div.dup-dlg-recover {
margin:auto;
margin:50px 0 0 0;
padding:2px;
width:100%;
text-align:center
}
div.dup-dlg-recover button {
width:300px;
height:50px
}
div.dup-dlg-recover button small {
display:block;
padding:0;
margin:-5px 0 0 0
}
div.dup-dlg-recover-choose {
padding:5px
}
div.dup-dlg-recover-or {
margin:15px 15px 15px 0;
font-size:18px;
color:#999;
font-weight:bold
}
span.dup-dlg-recover-msg-active {
display:block;
margin:0;
padding:2px
}
div.dup-dlg-recover-link{
text-align: center;
}

Some files were not shown because too many files have changed in this diff Show More