google-extensions.php — UpdraftPlus: WP Backup & Migration Plugin 1.26.4

updraftplus / includes / google-extensions.php

updraftplus / includes Last commit date

google-extensions.php

325 lines

1	<?php
2
3	if (!defined('UPDRAFTPLUS_DIR')) die('No direct access allowed.');
4
5	/*
6
7	// Unfortunately, since the variables we want to access are private, not protected, we can't just extend the class. Instead, we have to clone it, and add these methods into our cloned copy.
8
9	class UpdraftPlus_Google_Http_MediaFileUpload extends Google_Http_MediaFileUpload {
10	public function updraftplus_setResumeUri($resumeUri) { $this->resumeUri = $resumeUri; }
11	public function updraftplus_setProgress($progress) { $this->progress = $progress; }
12	// N.B. a public method getResumeUri already exists - and does something completely different
13	public function updraftplus_getResumeUri() { return empty($this->resumeUri) ? '' : $this->resumeUri; }
14	}
15	*/
16
17	/**
18	* Copyright 2012 Google Inc.
19	*
20	* Licensed under the Apache License, Version 2.0 (the "License");
21	* you may not use this file except in compliance with the License.
22	* You may obtain a copy of the License at
23	*
24	* http://www.apache.org/licenses/LICENSE-2.0
25	*
26	* Unless required by applicable law or agreed to in writing, software
27	* distributed under the License is distributed on an "AS IS" BASIS,
28	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
29	* See the License for the specific language governing permissions and
30	* limitations under the License.
31	*/
32
33	if (!class_exists('UDP_Google_Client')) {
34	require_once dirname(__FILE__) . '/Google/autoload.php';
35	}
36
37	/**
38	* Manage large file uploads, which may be media but can be any type
39	* of sizable data.
40	*/
41	class UpdraftPlus_Google_Http_MediaFileUpload
42	{
43
44	public function updraftplus_setResumeUri($resumeUri) { $this->resumeUri = $resumeUri; }
45	public function updraftplus_setProgress($progress) { $this->progress = $progress; }
46	//N.B. a public method getResumeUri already exists - and does something completely different
47	public function updraftplus_getResumeUri() { return $this->resumeUri; }
48
49	const UPLOAD_MEDIA_TYPE = 'media';
50	const UPLOAD_MULTIPART_TYPE = 'multipart';
51	const UPLOAD_RESUMABLE_TYPE = 'resumable';
52
53	/** @var string $mimeType */
54	private $mimeType;
55
56	/** @var string $data */
57	private $data;
58
59	/** @var bool $resumable */
60	private $resumable;
61
62	/** @var int $chunkSize */
63	private $chunkSize;
64
65	/** @var int $size */
66	private $size;
67
68	/** @var string $resumeUri */
69	private $resumeUri;
70
71	/** @var int $progress */
72	private $progress;
73
74	/** @var UDP_Google_Client */
75	private $client;
76
77	/** @var Google_Http_Request */
78	private $request;
79
80	/** @var string */
81	private $boundary;
82
83	/**
84	* Result code from last HTTP call
85	* @var int
86	*/
87	private $httpResultCode;
88
89	/**
90	* @param $mimeType string
91	* @param $data string The bytes you want to upload.
92	* @param $resumable bool
93	* @param bool $chunkSize File will be uploaded in chunks of this many bytes.
94	* only used if resumable=True
95	*/
96	public function __construct(
97	UDP_Google_Client $client,
98	UDP_Google_Http_Request $request,
99	$mimeType,
100	$data,
101	$resumable = false,
102	$chunkSize = false,
103	$boundary = false
104	) {
105	$this->client = $client;
106	$this->request = $request;
107	$this->mimeType = $mimeType;
108	$this->data = $data;
109	$this->size = is_null($this->data) ? 0 : strlen($this->data);
110	$this->resumable = $resumable;
111	if (!$chunkSize) {
112	$chunkSize = 256 * 1024;
113	}
114	$this->chunkSize = $chunkSize;
115	$this->progress = 0;
116	$this->boundary = $boundary;
117
118	// Process Media Request
119	$this->process();
120	}
121
122	/**
123	* Set the size of the file that is being uploaded.
124	* @param $size - int file size in bytes
125	*/
126	public function setFileSize($size)
127	{
128	$this->size = $size;
129	}
130
131	/**
132	* Return the progress on the upload
133	* @return int progress in bytes uploaded.
134	*/
135	public function getProgress()
136	{
137	return $this->progress;
138	}
139
140	/**
141	* Return the HTTP result code from the last call made.
142	* @return int code
143	*/
144	public function getHttpResultCode()
145	{
146	return $this->httpResultCode;
147	}
148
149	/**
150	* Send the next part of the file to upload.
151	*
152	* @param [$chunk] the next set of bytes to send. If false will used $data passed
153	* at construct time.
154	*/
155	public function nextChunk($chunk = false)
156	{
157	if (false == $this->resumeUri) {
158	$this->resumeUri = $this->getResumeUri();
159	}
160
161	if (false == $chunk) {
162	$chunk = substr($this->data, $this->progress, $this->chunkSize);
163	}
164
165	$lastBytePos = $this->progress + strlen($chunk) - 1;
166	$headers = array(
167	'content-range' => "bytes $this->progress-$lastBytePos/$this->size",
168	'content-type' => $this->request->getRequestHeader('content-type'),
169	'content-length' => strlen($chunk),
170	'expect' => '',
171	);
172
173	$httpRequest = new UDP_Google_Http_Request(
174	$this->resumeUri,
175	'PUT',
176	$headers,
177	$chunk
178	);
179
180	if ($this->client->getClassConfig("UDP_Google_Http_Request", "enable_gzip_for_uploads")) {
181	$httpRequest->enableGzip();
182	} else {
183	$httpRequest->disableGzip();
184	}
185
186	$response = $this->client->getIo()->makeRequest($httpRequest);
187	$response->setExpectedClass($this->request->getExpectedClass());
188	$code = $response->getResponseHttpCode();
189	$this->httpResultCode = $code;
190
191	if (308 == $code) {
192	// Track the amount uploaded.
193	$range = explode('-', $response->getResponseHeader('range'));
194	$this->progress = $range[1] + 1;
195
196	// Allow for changing upload URLs.
197	$location = $response->getResponseHeader('location');
198	if ($location) {
199	$this->resumeUri = $location;
200	}
201
202	// No problems, but upload not complete.
203	return false;
204	} else {
205	return UDP_Google_Http_REST::decodeHttpResponse($response, $this->client);
206	}
207	}
208
209	/**
210	* @param $meta
211	* @param $params
212	* @return array\|bool
213	* @visible for testing
214	*/
215	private function process()
216	{
217	$postBody = false;
218	$contentType = false;
219
220	$meta = $this->request->getPostBody();
221	$meta = is_string($meta) ? json_decode($meta, true) : $meta;
222
223	$uploadType = $this->getUploadType($meta);
224	$this->request->setQueryParam('uploadType', $uploadType);
225	$this->transformToUploadUrl();
226	$mimeType = $this->mimeType ?
227	$this->mimeType :
228	$this->request->getRequestHeader('content-type');
229
230	if (self::UPLOAD_RESUMABLE_TYPE == $uploadType) {
231	$contentType = $mimeType;
232	$postBody = is_string($meta) ? $meta : json_encode($meta);
233	} else if (self::UPLOAD_MEDIA_TYPE == $uploadType) {
234	$contentType = $mimeType;
235	$postBody = $this->data;
236	} else if (self::UPLOAD_MULTIPART_TYPE == $uploadType) {
237	// This is a multipart/related upload.
238	$boundary = $this->boundary ? $this->boundary : wp_rand();
239	$boundary = str_replace('"', '', $boundary);
240	$contentType = 'multipart/related; boundary=' . $boundary;
241	$related = "--$boundary\r\n";
242	$related .= "Content-Type: application/json; charset=UTF-8\r\n";
243	$related .= "\r\n" . json_encode($meta) . "\r\n";
244	$related .= "--$boundary\r\n";
245	$related .= "Content-Type: $mimeType\r\n";
246	$related .= "Content-Transfer-Encoding: base64\r\n";
247	$related .= "\r\n" . base64_encode($this->data) . "\r\n";
248	$related .= "--$boundary--";
249	$postBody = $related;
250	}
251
252	$this->request->setPostBody($postBody);
253
254	if (isset($contentType) && $contentType) {
255	$contentTypeHeader['content-type'] = $contentType;
256	$this->request->setRequestHeaders($contentTypeHeader);
257	}
258	}
259
260	private function transformToUploadUrl()
261	{
262	$base = $this->request->getBaseComponent();
263	$this->request->setBaseComponent($base . '/upload');
264	}
265
266	/**
267	* Valid upload types:
268	* - resumable (UPLOAD_RESUMABLE_TYPE)
269	* - media (UPLOAD_MEDIA_TYPE)
270	* - multipart (UPLOAD_MULTIPART_TYPE)
271	* @param $meta
272	* @return string
273	* @visible for testing
274	*/
275	public function getUploadType($meta)
276	{
277	if ($this->resumable) {
278	return self::UPLOAD_RESUMABLE_TYPE;
279	}
280
281	if (false == $meta && $this->data) {
282	return self::UPLOAD_MEDIA_TYPE;
283	}
284
285	return self::UPLOAD_MULTIPART_TYPE;
286	}
287
288	private function getResumeUri()
289	{
290	$result = null;
291	$body = $this->request->getPostBody();
292	if ($body) {
293	$headers = array(
294	'content-type' => 'application/json; charset=UTF-8',
295	'content-length' => Google_Utils::getStrLen($body),
296	'x-upload-content-type' => $this->mimeType,
297	'x-upload-content-length' => $this->size,
298	'expect' => '',
299	);
300	$this->request->setRequestHeaders($headers);
301	}
302
303	$response = $this->client->getIo()->makeRequest($this->request);
304	$location = $response->getResponseHeader('location');
305	$code = $response->getResponseHttpCode();
306
307	if (200 == $code && true == $location) {
308	return $location;
309	}
310	$message = $code;
311	$body = @json_decode($response->getResponseBody());
312	if (!empty( $body->error->errors ) ) {
313	$message .= ': ';
314	foreach ($body->error->errors as $error) {
315	$message .= "{$error->domain}, {$error->message};";
316	}
317	$message = rtrim($message, ';');
318	}
319
320	$error = "Failed to start the resumable upload (HTTP {$message})";
321	$this->client->getLogger()->error($error);
322	throw new Google_Exception($error); // phpcs:ignore WordPress.Security.EscapeOutput.ExceptionNotEscaped -- Error message to be escaped when caught and printed.
323	}
324	}
325