Your IP : 216.73.216.95
<?php
defined("ABSPATH") or die("");
use Duplicator\Models\Storages\GDriveStorage;
use Duplicator\Models\SystemGlobalEntity;
use Duplicator\Utils\Crypt\CryptBlowfish;
require_once(DUPLICATOR____PATH . '/lib/google/apiclient/autoload.php');
require_once(DUPLICATOR____PATH . '/lib/google/class.enhanced.google.media.file.upload.php');
class DUP_PRO_GDriveClient_UploadInfo
{
/** @var string */
public $resume_uri = '';
/** @var int */
public $next_offset = 0;
/** @var ?string */
public $error_details = null;
/** @var bool */
public $is_complete = false;
}
class DUP_PRO_GDrive_U
{
const RedirectUri = "https://snapcreek.com/misc/gdrive/auth_callback.php";
const UploadChunkSizeBytes = 1048576; // 2097152;
// These are requested scopes, possibly can be different than required scopes
const SCOPES = array(
"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",
);
const REQUIRED_SCOPES = array(
"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 directory view link
*
* @param Duplicator_Pro_Google_Service_Drive $google_service_drive Google service drive
* @param string $directory Directory
*
* @return string|null
*/
public static function get_directory_view_link(Duplicator_Pro_Google_Service_Drive $google_service_drive, $directory)
{
$directory_id = DUP_PRO_GDrive_U::get_directory_id($google_service_drive, $directory);
if ($directory_id != null) {
$directory_metadata = DUP_PRO_GDrive_U::get_file_metadata_by_id($google_service_drive, $directory_id);
if ($directory_metadata != null) {
DUP_PRO_Log::trace("Directory link = " . $directory_metadata->alternateLink); // @phpstan-ignore-line
return $directory_metadata->alternateLink; // @phpstan-ignore-line
} else {
DUP_PRO_Log::trace("Directory link for $directory not found");
return null;
}
} else {
DUP_PRO_Log::trace("Directory id for $directory not found");
return null;
}
}
/**
* Get file metada
*
* @param Duplicator_Pro_Google_Service_Drive $google_service_drive Google service drive
* @param string $file_id File id
*
* @return false|Duplicator_Pro_Google_Service_Drive_DriveFile false on failure
*/
public static function get_file_metadata_by_id(Duplicator_Pro_Google_Service_Drive $google_service_drive, $file_id)
{
try {
$file_metadata = $google_service_drive->files->get($file_id);
} catch (Exception $ex) {
DUP_PRO_Log::trace("Problems retrieving metadata for file $file_id");
return false;
}
return $file_metadata;
}
/**
* Delete file
*
* @param Duplicator_Pro_Google_Service_Drive $google_service_drive Google service drive
* @param string $file_id File id
*
* @return bool
*/
public static function delete_file(Duplicator_Pro_Google_Service_Drive $google_service_drive, $file_id)
{
$success = false;
try {
$google_service_drive->files->delete($file_id);
$success = true;
DUP_PRO_Log::trace("Delete of Google Drive file $file_id succeeded");
} catch (Exception $ex) {
DUP_PRO_Log::trace("Exception when trying to delete Google Drive file id $file_id");
}
return $success;
}
/**
* Retrieve files in a given directory orderd by creation date
*
* @param Duplicator_Pro_Google_Service_Drive $google_service_drive Google service drive
* @param string $directory_id Directory id
*
* @return null|object[]
*/
public static function get_files_in_directory(Duplicator_Pro_Google_Service_Drive $google_service_drive, $directory_id)
{
$file_items = null;
$parameters = array(
'orderBy' => 'createdTime',
'q' => "'$directory_id' in parents and trashed=false",
);
try {
$file_list = $google_service_drive->files->listFiles($parameters);
$file_items = $file_list->getFiles();
} catch (Exception $ex) {
DUP_PRO_Log::trace("Error retrieving file list for directory ID $directory_id " . $ex->getMessage());
}
return $file_items;
}
/**
* Get file
*
* @param Duplicator_Pro_Google_Service_Drive $google_service_drive Google service drive
* @param string $filename Filename
* @param string $directory_id Directory id
*
* @return null|string
*/
public static function get_file(
Duplicator_Pro_Google_Service_Drive $google_service_drive,
$filename,
$directory_id
) {
DUP_PRO_Log::trace("get_file for $filename $directory_id");
$file_id = null;
$file_items = self::get_files_in_directory($google_service_drive, $directory_id);
if ($file_items != null) {
foreach ($file_items as $drive_file) {
/* @var $drive_file Duplicator_Pro_Google_Service_Drive_DriveFile */
$google_filename = $drive_file->getName();
if ($google_filename == $filename) {
$file_id = $drive_file->getId();
break;
}
}
} else {
DUP_PRO_Log::trace("files in directory $directory_id are null");
}
return $file_id;
}
/**
* Get directory id
*
* @param Duplicator_Pro_Google_Service_Drive $google_service_drive Google service drive
* @param string $path Path
* @param bool $autocreate Autocreate
*
* @return null|string
*/
public static function get_directory_id(
Duplicator_Pro_Google_Service_Drive $google_service_drive,
$path,
$autocreate = true
) {
$parent_id = 'root';
$path = str_replace('\\', '/', $path);
$path = trim(trim($path), '/'); // Remove whitespaces and slashes from both ends of path
$path = preg_replace('#/+#', '/', $path); // Replace all duplicated slashes with a single slash
if ($path == "") {
return $parent_id;
}
$directory_parts = explode('/', $path);
try {
foreach ($directory_parts as $subdirectory) {
$parameters = array();
$parameters['q'] = "'$parent_id' in parents and mimeType = 'application/vnd.google-apps.folder' and trashed=false";
$file_list = $google_service_drive->files->listFiles($parameters);
$folder_id = '';
//DUP_PRO_Log::traceObject('#### file_list', $file_list);
//$items = $file_list->getItems();
$items = $file_list->getFiles();
foreach ($items as $drive_file) {
/* @var $drive_file Duplicator_Pro_Google_Service_Drive_DriveFile */
if ($drive_file->name == $subdirectory) {
$folder_id = $drive_file->id;
break;
} else {
DUP_PRO_Log::trace("{$drive_file->name} doesnt equal $subdirectory");
}
}
if ($folder_id == '') {
if ($autocreate) {
DUP_PRO_Log::trace("Creating new folder " . $subdirectory);
// Folder wasn't present so we have to create one
$folder_file = new Duplicator_Pro_Google_Service_Drive_DriveFile();
$folder_file->setName($subdirectory);
$folder_file->setMimeType('application/vnd.google-apps.folder');
$folder_file->setParents(array($parent_id));
$created_file = $google_service_drive->files->create($folder_file, array('mimeType' => 'application/vnd.google-apps.folder'));
$folder_id = $created_file->id;
} else {
// Doesn't exist
$parent_id = null;
}
}
$parent_id = $folder_id;
}
} catch (Exception $ex) {
DUP_PRO_Log::trace("Got error when trying to get directory id for $path: " . $ex->getMessage());
$parent_id = null;
}
return $parent_id;
}
/**
* Upload file
*
* @param Duplicator_Pro_Google_Client $google_client Google client
* @param string $src_file_path Source file path
* @param string $parent_file_id Parent file id
* @param string $dest_file_name Destination file name
*
* @return null|Duplicator_Pro_Google_Service_Drive_DriveFile
*/
public static function upload_file(
Duplicator_Pro_Google_Client $google_client,
$src_file_path,
$parent_file_id,
$dest_file_name = ''
) {
/* @var $google_Client Duplicator_Pro_Google_Client */
$drive_file = null;
/* @var $google_service_drive Duplicator_Pro_Google_Service_Drive */
try {
$mime_type = 'application/octet-stream';
$google_service_drive = new Duplicator_Pro_Google_Service_Drive($google_client);
$upload_file = new Duplicator_Pro_Google_Service_Drive_DriveFile();
//$upload_file->setTitle(basename($src_file_path));
if (empty($dest_file_name)) {
$dest_file_name = basename($src_file_path);
}
$upload_file->setName($dest_file_name);
$upload_file->setMimeType($mime_type);
$upload_file->setParents(array($parent_file_id));
try {
$data = file_get_contents($src_file_path);
if ($data !== false) {
// DUP_PRO_Log::traceObject("file to upload", $upload_file)
/* @var $drive_file Duplicator_Pro_Google_Service_Drive_DriveFile */
$drive_file = $google_service_drive->files->create($upload_file, array('data' => $data, 'uploadType' => 'media'));
} else {
DUP_PRO_Log::trace("Couldn't read file contents from $src_file_path when attempting Google Drive Upload");
}
} catch (Exception $ex) {
DUP_PRO_Log::trace("Exception from Google drive insert of $src_file_path " . $ex->getMessage());
}
if (isset($drive_file) == false) {
DUP_PRO_Log::trace("File returned from Google drive insert of $src_file_path is null.");
}
} catch (Exception $ex) {
DUP_PRO_Log::trace("Error uploading $src_file_path to Google Drive");
}
return $drive_file;
}
/**
* Upload file chunk
*
* @param Duplicator_Pro_Google_Client $google_client Google client
* @param string $src_file_path Source file path
* @param string $parent_file_id Parent file id
* @param int $upload_chunk_size Upload chunk size
* @param int $max_upload_time_in_sec Max upload time in sec
* @param int $next_offset Next offset
* @param string $resume_uri Resume uri
* @param int $server_load_delay Server load delay
*
* @return DUP_PRO_GDriveClient_UploadInfo
*/
public static function upload_file_chunk(
Duplicator_Pro_Google_Client $google_client,
$src_file_path,
$parent_file_id,
$upload_chunk_size = self::UploadChunkSizeBytes,
$max_upload_time_in_sec = 10,
$next_offset = 0,
$resume_uri = null,
$server_load_delay = 0
) {
$upload_info = new DUP_PRO_GDriveClient_UploadInfo();
try {
if (file_exists($src_file_path) == false) {
$upload_info->error_details = "$src_file_path doesn't exist!";
}
$google_service_drive = new Duplicator_Pro_Google_Service_Drive($google_client);
$google_client->setDefer(true);
$upload_file = new Duplicator_Pro_Google_Service_Drive_DriveFile();
$upload_file->name = basename($src_file_path);
$upload_file->setMimeType('application/octet-stream');
$upload_file->setParents(array($parent_file_id));
$request = $google_service_drive->files->create($upload_file);
if ($resume_uri == null) {
$resume_uri = false;
}
$media_file_upload = new DUP_Pro_EnhancedGoogleMediaFileUpload(
$google_client,
$request,
'binary/octet-stream',
null,
true,
$upload_chunk_size,
false,
$next_offset,
$resume_uri
);
$media_file_upload->setFileSize(filesize($src_file_path));
// Upload the various chunks. $status will be false until the process is complete.
$handle = fopen($src_file_path, "rb");
if ($handle != false) {
fseek($handle, $next_offset);
$start_time = time();
$time_passed = 0;
while (!$upload_info->is_complete && !feof($handle) && ($time_passed < $max_upload_time_in_sec)) {
if ($server_load_delay !== 0) {
usleep($server_load_delay);
}
$chunk = self::read_file_chunk($handle, $upload_chunk_size);
$upload_info->is_complete = ($media_file_upload->nextChunk($chunk) !== false);
$upload_info->resume_uri = $media_file_upload->resumeUri;
$upload_info->next_offset = $media_file_upload->getNextOffset();
fseek($handle, $upload_info->next_offset);
$time_passed = time() - $start_time;
}
if ($upload_info->is_complete) {
DUP_PRO_Log::trace("Upload info is complete!");
}
fclose($handle);
} else {
$upload_info->error_details = "Error opening $src_file_path";
}
} catch (Exception $ex) {
$message = $ex->getMessage();
$upload_info->error_details = "Error uploading to Google Drive: " . $message;
if (DUP_PRO_STR::contains($message, 'storage quota has been exceeded')) {
$system_global = SystemGlobalEntity::getInstance();
$system_global->addTextFix(
esc_html__('Google Drive out of storage space', "duplicator-pro"),
esc_html__('Free up space on Google Drive or increase storage quota.', "duplicator-pro")
);
}
}
$google_client->setDefer(false);
return $upload_info;
}
/**
* Download file
*
* @param Duplicator_Pro_Google_Client $google_client Google client
* @param Duplicator_Pro_Google_Service_Drive_DriveFile $google_file Google file
* @param string $local_filepath Local filepath
* @param bool $overwrite_local Overwrite local
*
* @return bool
*/
public static function download_file(
Duplicator_Pro_Google_Client $google_client,
Duplicator_Pro_Google_Service_Drive_DriveFile $google_file,
$local_filepath,
$overwrite_local = true
) {
$success = false;
if ($overwrite_local || (file_exists($local_filepath) === false)) {
$google_service_drive = new Duplicator_Pro_Google_Service_Drive($google_client);
$file_contents = $google_service_drive->files->get($google_file->id, array('alt' => 'media'));
if (@file_put_contents($local_filepath, $file_contents) === false) {
DUP_PRO_Log::trace("Problem writing downloaded file to $local_filepath!");
} else {
$success = true;
}
} else {
DUP_PRO_Log::trace("Attempted to download a file to $local_filepath but that file already exists!");
}
return $success;
}
/**
* Read file chunk
*
* @param resource $handle Handle
* @param int $chunk_size Chunk size
*
* @return string
*/
public static function read_file_chunk($handle, $chunk_size)
{
$byte_count = 0;
$giant_chunk = "";
while (!feof($handle)) {
// fread will never return more than 8192 bytes if the stream is read buffered and it does not represent a plain file
$chunk = fread($handle, 8192);
$byte_count += strlen($chunk);
$giant_chunk .= $chunk;
if ($byte_count >= $chunk_size) {
return $giant_chunk;
}
}
return $giant_chunk;
}
/**
* Return user info
*
* @param Duplicator_Pro_Google_Client $google_client Google client
*
* @return ?Duplicator_Pro_Google_Service_Oauth2_Userinfoplus
*/
public static function get_user_info(Duplicator_Pro_Google_Client $google_client)
{
$userInfoService = new Duplicator_Pro_Google_Service_Oauth2($google_client);
$userInfo = null;
try {
$userInfo = $userInfoService->userinfo->get();
} catch (Duplicator_Pro_Google_Exception $e) {
DUP_PRO_Log::trace("Error retrieving user information");
}
if ($userInfo->getId() == null) {
$userInfo = null;
}
return $userInfo;
}
/**
* Returns binary self value
*
* @return string
*/
public static function get_binary_self_value()
{
return 'jfds2!x4';
}
/**
* Returns binary extraction value
*
* @return string
*/
public static function get_binary_extraction_value()
{
return 'kkd23p';
}
/**
* Returns true if all required scopes are permitted, else returns false
*
* @param string $scopesToCheck Scopes to check, delimiter is space
*
* @return boolean
*/
public static function checkScopes($scopesToCheck)
{
$scopesToCheck = preg_split('~\s+~', $scopesToCheck, -1, PREG_SPLIT_NO_EMPTY);
if ($scopesToCheck == false) {
return false;
}
$ok = true;
foreach (self::REQUIRED_SCOPES as $requiredScope) {
if (!in_array($requiredScope, $scopesToCheck)) {
$ok = false;
break;
}
}
return $ok;
}
/**
* Get google client
*
* @param int $gdrive_client_number Gdrive client number
*
* @return Duplicator_Pro_Google_Client
*/
public static function get_raw_google_client($gdrive_client_number = null)
{
$global = DUP_PRO_Global_Entity::getInstance();
$client = new Duplicator_Pro_Google_Client();
if ($global->gdrive_transfer_mode == DUP_PRO_Google_Drive_Transfer_Mode::FOpen_URL) {
$io = new Duplicator_Pro_Google_IO_Stream($client);
$client->setIo($io);
}
$io = $client->getIo();
$setopts = array();
if (is_a($io, 'Duplicator_Pro_Google_IO_Curl')) {
$setopts[CURLOPT_SSL_VERIFYPEER] = $global->ssl_disableverify ? false : true;
$setopts[CURLOPT_SSL_VERIFYHOST] = $global->ssl_disableverify ? 0 : 2;
if (!$global->ssl_useservercerts) {
$setopts[CURLOPT_CAINFO] = DUPLICATOR_PRO_CERT_PATH;
$setopts[CURLOPT_CAPATH] = DUPLICATOR_PRO_CERT_PATH;
}
// Raise the timeout from the default of 15
$setopts[CURLOPT_TIMEOUT] = 360;
$setopts[CURLOPT_CONNECTTIMEOUT] = 180;
if ($global->ipv4_only) {
$setopts[CURLOPT_IPRESOLVE] = CURL_IPRESOLVE_V4;
}
} elseif (is_a($io, 'Duplicator_Pro_Google_IO_Stream')) {
$setopts['timeout'] = 360;
// https://wiki.php.net/rfc/tls-peer-verification - before PHP 5.6, there is no default CA file
if (!$global->ssl_useservercerts || (version_compare(PHP_VERSION, '5.6.0', '<'))) {
$setopts['cafile'] = DUPLICATOR_PRO_CERT_PATH;
}
if ($global->ssl_disableverify) {
$setopts['disable_verify_peer'] = true;
}
}
$io->setOptions($setopts);
$sv = self::get_binary_self_value();
$ev = self::get_binary_extraction_value();
$ci = CryptBlowfish::decrypt('EQNJ53++6/40fuF5ke+IaQ==', $sv);
$cs = CryptBlowfish::decrypt('ui25chqoBexPt6QDi9qmGg==', $ev);
$ci = trim($ci);
$cs = trim($cs);
switch ($gdrive_client_number) {
case GDriveStorage::GDRIVE_CLIENT_NATIVE:
if (($ci != $cs) || ($ci != "x93fdf8")) {
$ci = self::get_cj1() . self::get_cj2();
$cs = self::get_ct1() . self::get_ct2();
}
break;
case GDriveStorage::GDRIVE_CLIENT_WEB0722:
case GDriveStorage::GDRIVE_CLIENT_LATEST:
default:
if (($ci != $cs) || ($ci != "x93fdf8")) {
$ci = self::get_cj3() . self::get_cj4();
$cs = self::get_ct3() . self::get_ct4();
}
}
$client->setClientId($ci);
$client->setAccessType('offline');
$client->setClientSecret($cs);
$client->setScopes(self::SCOPES);
$client->setRedirectUri(self::RedirectUri);
return $client;
}
/**
* Returns part of ci
*
* @return string
*/
private static function get_cj1()
{
return base64_decode('MTMwOTA5MDkxOTkzLTZlMzFpNHN2cW9uaG9iMmRz');
}
/**
* Returns part of ci
*
* @return string
*/
private static function get_cj2()
{
return base64_decode('a2Zkc2R2cThvbWxnN3RlLmFwcHMuZ29vZ2xldXNlcmNvbnRlbnQuY29t');
}
/**
* Returns part of ci
*
* @return string
*/
private static function get_cj3()
{
return base64_decode('MTMwOTA5MDkxOTkzLWVwbWY2aHBjZnNmbDduZW5p');
}
/**
* Returns part of ci
*
* @return string
*/
private static function get_cj4()
{
return base64_decode('MzV0cjNjb2VvcXRvcDhjLmFwcHMuZ29vZ2xldXNlcmNvbnRlbnQuY29t');
}
/**
* Returns part of cs
*
* @return string
*/
private static function get_ct1()
{
return base64_decode('SVltaThQVnlzblFNbGo3');
}
/**
* Returns part of cs
*
* @return string
*/
private static function get_ct2()
{
return base64_decode('dHhuakgzN09t');
}
/**
* Returns part of cs
*
* @return string
*/
private static function get_ct3()
{
return base64_decode('R09DU1BYLWlIU3VZYnY1VHZa');
}
/**
* Returns part of cs
*
* @return string
*/
private static function get_ct4()
{
return base64_decode('SmJLVUIxa1VCclBIeG1JNGs=');
}
}