| 1 |
<?php |
| 2 |
/** |
| 3 |
* Unified export API for SQL and file operations. |
| 4 |
*/ |
| 5 |
|
| 6 |
use WordPress\Reprint\Server\FileIndexProcessor; |
| 7 |
use WordPress\Reprint\Server\FileTreeProducer; |
| 8 |
use WordPress\Reprint\Server\GzipOutputStream; |
| 9 |
use WordPress\Reprint\Server\MySQLDumpProducer; |
| 10 |
use WordPress\Reprint\Server\PdoConstants; |
| 11 |
use WordPress\Reprint\Server\ResourceBudget; |
| 12 |
use WordPress\Reprint\Server\SqliteDriverPDO; |
| 13 |
use WordPress\Reprint\Server\WpdbDriverPDO; |
| 14 |
|
| 15 |
use function WordPress\Reprint\Server\assert_valid_path; |
| 16 |
use function WordPress\Reprint\Server\build_pdo_dsn; |
| 17 |
use function WordPress\Reprint\Server\generate_random_bytes; |
| 18 |
use function WordPress\Reprint\Server\json_encode_or_throw; |
| 19 |
use function WordPress\Reprint\Server\normalize_path; |
| 20 |
use function WordPress\Reprint\Server\parse_size; |
| 21 |
use function WordPress\Reprint\Server\path_is_same_as_or_descendant_of; |
| 22 |
use function WordPress\Reprint\Server\trim_right_slash; |
| 23 |
use function WordPress\Reprint\Server\wp_join_unix_paths; |
| 24 |
|
| 25 |
require_once __DIR__ . '/utils.php'; |
| 26 |
require_once __DIR__ . '/class-resource-budget.php'; |
| 27 |
require_once __DIR__ . '/class-gzip-output-stream.php'; |
| 28 |
require_once __DIR__ . '/class-file-index-processor.php'; |
| 29 |
|
| 30 |
// Capture any accidental output before headers are set so we can discard it |
| 31 |
// when switching to streaming mode later. |
| 32 |
if (!ob_get_level()) { |
| 33 |
ob_start(); |
| 34 |
} |
| 35 |
|
| 36 |
|
| 37 |
/** |
| 38 |
* The wire-protocol version this export plugin speaks. |
| 39 |
* |
| 40 |
* The export plugin and importer report this value during preflight so a |
| 41 |
* mismatched deployment fails before any content is transferred. |
| 42 |
* |
| 43 |
* EXPORT_PROTOCOL_VERSION is sent to the importer in the preflight JSON |
| 44 |
* response as `protocol_version`. Bump it whenever a change to the wire |
| 45 |
* protocol (cursor encoding, multipart structure, header names, endpoint |
| 46 |
* parameters, response format) would break an older importer. |
| 47 |
*/ |
| 48 |
define('EXPORT_PROTOCOL_VERSION', 3); |
| 49 |
|
| 50 |
// File type mask + file type values (top bits of st_mode) |
| 51 |
define('STAT_TYPE_MASK', 0170000); |
| 52 |
define('STAT_TYPE_SOCKET', 0140000); |
| 53 |
define('STAT_TYPE_LINK', 0120000); |
| 54 |
define('STAT_TYPE_FILE', 0100000); |
| 55 |
define('STAT_TYPE_BLOCK', 0060000); |
| 56 |
define('STAT_TYPE_DIR', 0040000); |
| 57 |
define('STAT_TYPE_CHAR', 0020000); |
| 58 |
define('STAT_TYPE_FIFO', 0010000); |
| 59 |
|
| 60 |
/** |
| 61 |
* Global streaming context. When set, the error handlers emit error chunks |
| 62 |
* into the active multipart stream instead of sending plain JSON, which would |
| 63 |
* corrupt either a compressed or uncompressed multipart response. |
| 64 |
* |
| 65 |
* Set by each streaming endpoint right after creating $gz and $boundary. |
| 66 |
* Keys: 'gz' => GzipOutputStream, 'boundary' => string |
| 67 |
*/ |
| 68 |
$streaming_context = null; |
| 69 |
|
| 70 |
/** |
| 71 |
* Initializes a multipart/mixed streaming response, optionally with gzip compression. |
| 72 |
* |
| 73 |
* Every streaming endpoint needs the same setup: a unique boundary, the |
| 74 |
* Content-Type header, an output stream, and the global $streaming_context so |
| 75 |
* error handlers can emit structured error chunks mid-stream. |
| 76 |
* |
| 77 |
* @param bool $require_headers If true, throws when headers were already sent |
| 78 |
* (use for endpoints that can't degrade gracefully). |
| 79 |
* @param bool $gzip If true, emit Content-Encoding: gzip and compress the body. |
| 80 |
* @return array { |
| 81 |
* Multipart stream context. |
| 82 |
* |
| 83 |
* @type GzipOutputStream $gz Output stream used by the response. |
| 84 |
* @type string $boundary MIME boundary for response parts. |
| 85 |
* } |
| 86 |
* @phpstan-return array{gz: GzipOutputStream, boundary: string} |
| 87 |
*/ |
| 88 |
function begin_multipart_stream(bool $require_headers = false, bool $gzip = true): array |
| 89 |
{ |
| 90 |
global $streaming_context; |
| 91 |
|
| 92 |
/** |
| 93 |
* We're choosing a random boundary without checking for its presence in the content. |
| 94 |
* This may seem to contradict RFC 2046, where it says: |
| 95 |
* |
| 96 |
* > As stated previously, each body part is preceded by a boundary |
| 97 |
* > delimiter line that contains the boundary delimiter. The boundary |
| 98 |
* > delimiter MUST NOT appear inside any of the encapsulated parts, on a |
| 99 |
* > line by itself or as the prefix of any line. This implies that it is |
| 100 |
* > crucial that the composing agent be able to choose and specify a |
| 101 |
* > unique boundary parameter value that does not contain the boundary |
| 102 |
* > parameter value of an enclosing multipart as a prefix. |
| 103 |
* > |
| 104 |
* > https://www.rfc-editor.org/rfc/rfc2046.html |
| 105 |
* |
| 106 |
* But in practice, we're okay. We use 128 bits of randomness. The chance of |
| 107 |
* it appearing in the data is about 1 in 2^128 — effectively zero. Curl does |
| 108 |
* the same here: |
| 109 |
* |
| 110 |
* https://github.com/curl/curl/blob/462244447e8ba3a53b1ba9f0ba7baa52d8777daa/lib/mime.c#L1179-L1236 |
| 111 |
* |
| 112 |
* Also, every chunk declares its Content-Length, so the client never needs |
| 113 |
* to search arbitrary body bytes for the boundary. |
| 114 |
*/ |
| 115 |
$boundary = "boundary-" . bin2hex(generate_random_bytes(16)); |
| 116 |
$can_send_headers = !headers_sent(); |
| 117 |
|
| 118 |
if ($require_headers && !$can_send_headers) { |
| 119 |
throw new RuntimeException( |
| 120 |
"Cannot begin multipart stream: headers already sent" |
| 121 |
); |
| 122 |
} |
| 123 |
|
| 124 |
if ($can_send_headers) { |
| 125 |
@header("Content-Type: multipart/mixed; boundary=\"$boundary\""); |
| 126 |
} |
| 127 |
|
| 128 |
$gz = new GzipOutputStream($can_send_headers && $gzip); |
| 129 |
$streaming_context = ['gz' => $gz, 'boundary' => $boundary]; |
| 130 |
|
| 131 |
return $streaming_context; |
| 132 |
} |
| 133 |
|
| 134 |
/** |
| 135 |
* Resolves database credentials from PHP constants and environment variables. |
| 136 |
* |
| 137 |
* Never reads from $config / HTTP parameters — credentials must come from |
| 138 |
* the server environment (PHP constants or environment variables). |
| 139 |
* |
| 140 |
* @return array { |
| 141 |
* Database connection details resolved from the server environment. |
| 142 |
* |
| 143 |
* @type string $db_host Database host. |
| 144 |
* @type string $db_name Database name. |
| 145 |
* @type string $db_user Database user. |
| 146 |
* @type string $db_password Database password. |
| 147 |
* @type string|null $wp_config_path WordPress config path, if known. |
| 148 |
* @type string|null $table_prefix WordPress table prefix, if known. |
| 149 |
* } |
| 150 |
* @phpstan-return array{ |
| 151 |
* db_host: string, |
| 152 |
* db_name: string, |
| 153 |
* db_user: string, |
| 154 |
* db_password: string, |
| 155 |
* wp_config_path: ?string, |
| 156 |
* table_prefix: ?string |
| 157 |
* } |
| 158 |
* @throws InvalidArgumentException When required credentials are missing. |
| 159 |
*/ |
| 160 |
function resolve_db_credentials(): array |
| 161 |
{ |
| 162 |
$db_host = defined("DB_HOST") ? DB_HOST : getenv("DB_HOST"); |
| 163 |
$db_name = defined("DB_NAME") ? DB_NAME : getenv("DB_NAME"); |
| 164 |
$db_user = defined("DB_USER") ? DB_USER : getenv("DB_USER"); |
| 165 |
$db_password = defined("DB_PASSWORD") ? DB_PASSWORD : getenv("DB_PASSWORD"); |
| 166 |
|
| 167 |
global $wpdb; |
| 168 |
|
| 169 |
$wp_config_path = null; |
| 170 |
$table_prefix = null; |
| 171 |
if (isset($GLOBALS['table_prefix']) && is_string($GLOBALS['table_prefix']) && $GLOBALS['table_prefix'] !== '') { |
| 172 |
$table_prefix = $GLOBALS['table_prefix']; |
| 173 |
} elseif (isset($wpdb) && is_object($wpdb) && isset($wpdb->prefix) && is_string($wpdb->prefix) && $wpdb->prefix !== '') { |
| 174 |
$table_prefix = $wpdb->prefix; |
| 175 |
} |
| 176 |
|
| 177 |
// On SQLite sites, the driver is already loaded by WordPress via the |
| 178 |
// db.php drop-in. We just need to confirm it's available and skip the |
| 179 |
// MySQL credential requirements. |
| 180 |
if (is_sqlite_site()) { |
| 181 |
return [ |
| 182 |
"db_engine" => "sqlite", |
| 183 |
"db_host" => "", |
| 184 |
"db_name" => $db_name ?: "wordpress", |
| 185 |
"db_user" => "", |
| 186 |
"db_password" => "", |
| 187 |
"wp_config_path" => $wp_config_path, |
| 188 |
"table_prefix" => $table_prefix, |
| 189 |
]; |
| 190 |
} |
| 191 |
|
| 192 |
$missing = []; |
| 193 |
if (!$db_host) { $missing[] = "db_host"; } |
| 194 |
if (!$db_name) { $missing[] = "db_name"; } |
| 195 |
if (!$db_user) { $missing[] = "db_user"; } |
| 196 |
if ($db_password === false || $db_password === null) { |
| 197 |
$missing[] = "db_password"; |
| 198 |
} |
| 199 |
if (!empty($missing)) { |
| 200 |
throw new InvalidArgumentException( |
| 201 |
"Database credentials not found. Please provide via environment variables, " . |
| 202 |
"PHP constants, or ensure wp-config.php exists with valid credentials. " . |
| 203 |
"Missing: " . implode(", ", $missing) |
| 204 |
); |
| 205 |
} |
| 206 |
|
| 207 |
return [ |
| 208 |
"db_engine" => "mysql", |
| 209 |
"db_host" => $db_host, |
| 210 |
"db_name" => $db_name, |
| 211 |
"db_user" => $db_user, |
| 212 |
"db_password" => $db_password, |
| 213 |
"wp_config_path" => $wp_config_path, |
| 214 |
"table_prefix" => $table_prefix, |
| 215 |
]; |
| 216 |
} |
| 217 |
|
| 218 |
/** |
| 219 |
* Returns true when the current WordPress site uses the SQLite backend. |
| 220 |
* |
| 221 |
* The sqlite-database-integration plugin's db.php drop-in defines |
| 222 |
* SQLITE_DB_DROPIN_VERSION and exposes its PDO handle through $GLOBALS['@pdo']. |
| 223 |
*/ |
| 224 |
function is_sqlite_site(): bool |
| 225 |
{ |
| 226 |
// Connection setup checks which supported driver WordPress loaded. |
| 227 |
return defined('SQLITE_DB_DROPIN_VERSION') && isset($GLOBALS['@pdo']); |
| 228 |
} |
| 229 |
|
| 230 |
/** |
| 231 |
* Creates a database connection appropriate for the detected backend. |
| 232 |
* |
| 233 |
* For MySQL sites, returns a standard PDO connection, falling back to the |
| 234 |
* wpdb adapter when that connection fails and WordPress is loaded. |
| 235 |
* For SQLite sites, wraps the MySQL-on-SQLite driver which WordPress already |
| 236 |
* loaded in a PDO-compatible adapter. The driver's translator converts every |
| 237 |
* MySQL query to SQLite on the fly, so MySQLDumpProducer sees MySQL-shaped |
| 238 |
* results and produces valid MySQL SQL output. |
| 239 |
* |
| 240 |
* @param array $creds Credentials from resolve_db_credentials(). |
| 241 |
* @param array $options PDO options. Reach the real PDO connection only; the |
| 242 |
* wpdb adapter has no handle to set them on. |
| 243 |
* @return PDO A real PDO for MySQL, or a PDO-compatible adapter for SQLite |
| 244 |
* and for MySQL hosts reached through wpdb. |
| 245 |
*/ |
| 246 |
function create_db_connection(array $creds, array $options = []) |
| 247 |
{ |
| 248 |
if (($creds["db_engine"] ?? "mysql") === "sqlite") { |
| 249 |
return create_sqlite_pdo_adapter(); |
| 250 |
} |
| 251 |
|
| 252 |
// Gate on pdo_mysql, not pdo: ext-pdo core without the mysql driver |
| 253 |
// can't drive MySQL exports. |
| 254 |
if (!extension_loaded('pdo_mysql')) { |
| 255 |
$mysql = create_wpdb_pdo_adapter(); |
| 256 |
} else { |
| 257 |
// MySQL path (also works for HyperDB — wp-config.php credentials |
| 258 |
// point to the write master). |
| 259 |
$default_options = [ |
| 260 |
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, |
| 261 |
]; |
| 262 |
$merged_options = $options + $default_options; |
| 263 |
|
| 264 |
try { |
| 265 |
$mysql = new PDO( |
| 266 |
build_pdo_dsn($creds['db_host'], $creds['db_name']), |
| 267 |
$creds["db_user"], |
| 268 |
$creds["db_password"], |
| 269 |
$merged_options |
| 270 |
); |
| 271 |
} catch (PDOException $connection_error) { |
| 272 |
global $wpdb; |
| 273 |
if (!isset($wpdb) || !is_object($wpdb)) { |
| 274 |
throw $connection_error; |
| 275 |
} |
| 276 |
|
| 277 |
// Fallback to using wpdb if we failed to connect directly to the database. |
| 278 |
$mysql = create_wpdb_pdo_adapter(); |
| 279 |
} |
| 280 |
} |
| 281 |
|
| 282 |
// SET NAMES normalizes the client, connection, and result charsets plus |
| 283 |
// the connection collation for both PDO and wpdb. Text primary key |
| 284 |
// comparisons still use each column's stored collation. |
| 285 |
$mysql->query( |
| 286 |
"SET NAMES utf8mb4 COLLATE utf8mb4_bin" |
| 287 |
); |
| 288 |
|
| 289 |
return $mysql; |
| 290 |
} |
| 291 |
|
| 292 |
/** |
| 293 |
* Wraps the SQLite plugin's already-loaded driver in a PDO-compatible adapter. |
| 294 |
* |
| 295 |
* Version 3 exposes its active translator through $wpdb->get_driver(). Version |
| 296 |
* 2 exposes its active translator through wpdb's backward-compatible dbh |
| 297 |
* property. Both translate MySQL queries, but neither provides every PDO |
| 298 |
* operation used by MySQLDumpProducer. |
| 299 |
* |
| 300 |
* @return object PDO-compatible adapter (SqliteDriverPDO). |
| 301 |
* @throws RuntimeException If the driver is not available or unsupported. |
| 302 |
*/ |
| 303 |
function create_sqlite_pdo_adapter() |
| 304 |
{ |
| 305 |
global $wpdb; |
| 306 |
|
| 307 |
/** |
| 308 |
* Minimum supported sqlite-database-integration version. |
| 309 |
*/ |
| 310 |
$min_version = '2.1.0'; |
| 311 |
|
| 312 |
if (!class_exists('PDO', false)) { |
| 313 |
throw new RuntimeException('SQLite export requires the PDO extension.'); |
| 314 |
} |
| 315 |
|
| 316 |
require_once __DIR__ . "/class-sqlite-driver-pdo.php"; |
| 317 |
|
| 318 |
$driver = null; |
| 319 |
$raw_pdo = null; |
| 320 |
|
| 321 |
if (isset($wpdb) && is_object($wpdb) && method_exists($wpdb, 'get_driver')) { |
| 322 |
$candidate = $wpdb->get_driver(); |
| 323 |
if ( |
| 324 |
is_object($candidate) && |
| 325 |
method_exists($candidate, 'query') && |
| 326 |
method_exists($candidate, 'get_sqlite_pdo') |
| 327 |
) { |
| 328 |
$candidate_pdo = call_user_func([$candidate, 'get_sqlite_pdo']); |
| 329 |
} else { |
| 330 |
$candidate_pdo = null; |
| 331 |
} |
| 332 |
if ($candidate_pdo instanceof PDO) { |
| 333 |
$driver = $candidate; |
| 334 |
$raw_pdo = $candidate_pdo; |
| 335 |
} |
| 336 |
} |
| 337 |
|
| 338 |
if ($driver === null && isset($wpdb) && is_object($wpdb)) { |
| 339 |
$candidate = $wpdb->dbh; |
| 340 |
$candidate_pdo = null; |
| 341 |
if (is_object($candidate) && method_exists($candidate, 'query')) { |
| 342 |
if (method_exists($candidate, 'get_pdo')) { |
| 343 |
$candidate_pdo = call_user_func([$candidate, 'get_pdo']); |
| 344 |
} elseif (method_exists($candidate, 'get_connection')) { |
| 345 |
$connection = call_user_func([$candidate, 'get_connection']); |
| 346 |
if (is_object($connection) && method_exists($connection, 'get_pdo')) { |
| 347 |
$candidate_pdo = call_user_func([$connection, 'get_pdo']); |
| 348 |
} |
| 349 |
} |
| 350 |
} |
| 351 |
if ($candidate_pdo instanceof PDO) { |
| 352 |
$driver = $candidate; |
| 353 |
$raw_pdo = $candidate_pdo; |
| 354 |
} |
| 355 |
} |
| 356 |
|
| 357 |
if ($driver === null) { |
| 358 |
throw new RuntimeException( |
| 359 |
"SQLite export requires WordPress to load a supported " . |
| 360 |
"sqlite-database-integration driver." |
| 361 |
); |
| 362 |
} |
| 363 |
|
| 364 |
if ( |
| 365 |
defined('SQLITE_DRIVER_VERSION') && |
| 366 |
version_compare(SQLITE_DRIVER_VERSION, $min_version, '<') |
| 367 |
) { |
| 368 |
throw new RuntimeException( |
| 369 |
"sqlite-database-integration plugin version " . SQLITE_DRIVER_VERSION . |
| 370 |
" is too old. Minimum required: " . $min_version |
| 371 |
); |
| 372 |
} |
| 373 |
|
| 374 |
return new SqliteDriverPDO($driver, $raw_pdo); |
| 375 |
} |
| 376 |
|
| 377 |
/** |
| 378 |
* Wraps the global $wpdb in a PDO-shaped adapter. |
| 379 |
* |
| 380 |
* Used on hosts without ext-pdo_mysql. Requires WordPress to be loaded |
| 381 |
* (so $wpdb is available); throws otherwise. |
| 382 |
*/ |
| 383 |
function create_wpdb_pdo_adapter() |
| 384 |
{ |
| 385 |
global $wpdb; |
| 386 |
|
| 387 |
require_once __DIR__ . "/class-wpdb-driver-pdo.php"; |
| 388 |
|
| 389 |
// Guard against a clobbered/half-initialized $wpdb: isset() alone passes |
| 390 |
// for non-object scalars, which would fatal inside the adapter constructor. |
| 391 |
if (!isset($wpdb) || !is_object($wpdb)) { |
| 392 |
throw new RuntimeException( |
| 393 |
"MySQL export without PDO requires WordPress \$wpdb to be initialized." |
| 394 |
); |
| 395 |
} |
| 396 |
|
| 397 |
return new WpdbDriverPDO($wpdb); |
| 398 |
} |
| 399 |
|
| 400 |
if (!class_exists('Site_Export_HTTP_Server', false)) { |
| 401 |
require_once __DIR__ . "/class-http-server.php"; |
| 402 |
} |
| 403 |
|
| 404 |
/** |
| 405 |
* Emits an error chunk into a multipart stream. |
| 406 |
*/ |
| 407 |
function emit_error_chunk($gz, string $boundary, string $message): void |
| 408 |
{ |
| 409 |
$json = json_encode([ |
| 410 |
"error_type" => "php_error", |
| 411 |
"path" => "", |
| 412 |
"message" => $message, |
| 413 |
]); |
| 414 |
if ($json === false) { |
| 415 |
$json = '{"error_type":"php_error","path":"","message":"Error (json_encode failed)"}'; |
| 416 |
} |
| 417 |
$chunk = |
| 418 |
"--{$boundary}\r\n" . |
| 419 |
"Content-Type: application/json\r\n" . |
| 420 |
"Content-Length: " . strlen($json) . "\r\n" . |
| 421 |
"X-Chunk-Type: error\r\n" . |
| 422 |
"\r\n" . |
| 423 |
$json . "\r\n"; |
| 424 |
$write_failed = false; |
| 425 |
try { |
| 426 |
$gz->write($chunk); |
| 427 |
$gz->sync(); |
| 428 |
} catch (\Exception $e) { |
| 429 |
$write_failed = true; |
| 430 |
} catch (\Throwable $e) { |
| 431 |
$write_failed = true; |
| 432 |
} |
| 433 |
|
| 434 |
if ($write_failed) { |
| 435 |
// The output stream is broken, so make one last raw write. If gzip was |
| 436 |
// active, the client likely cannot parse it, but this is better than |
| 437 |
// silent failure. |
| 438 |
echo $chunk; |
| 439 |
flush(); |
| 440 |
} |
| 441 |
} |
| 442 |
|
| 443 |
// Streaming-aware error handler. Before streaming starts, errors produce |
| 444 |
// a JSON response with HTTP 500. Mid-stream, errors become multipart |
| 445 |
// error chunks so the client receives structured diagnostics. |
| 446 |
// |
| 447 |
// Respects the @ operator: suppressed errors are logged but never emitted |
| 448 |
// into the stream or sent as responses, since the calling code already |
| 449 |
// handles the failure (e.g. @readlink checks for false). |
| 450 |
set_error_handler(function ($errno, $errstr, $errfile, $errline) { |
| 451 |
global $streaming_context; |
| 452 |
|
| 453 |
$error = [ |
| 454 |
"error" => "PHP Error: $errstr", |
| 455 |
"file" => $errfile, |
| 456 |
"line" => $errline, |
| 457 |
"type" => $errno, |
| 458 |
]; |
| 459 |
|
| 460 |
if (!(error_reporting() & $errno)) { |
| 461 |
error_log("Export error (suppressed): " . json_encode($error)); |
| 462 |
return true; |
| 463 |
} |
| 464 |
|
| 465 |
error_log("Export error: " . json_encode($error)); |
| 466 |
|
| 467 |
if ($streaming_context !== null) { |
| 468 |
emit_error_chunk( |
| 469 |
$streaming_context['gz'], |
| 470 |
$streaming_context['boundary'], |
| 471 |
"PHP Error ({$errno}): {$errstr} in {$errfile}:{$errline}" |
| 472 |
); |
| 473 |
return true; |
| 474 |
} |
| 475 |
|
| 476 |
http_response_code(500); |
| 477 |
@header("Content-Type: application/json"); |
| 478 |
echo json_encode($error); |
| 479 |
exit(1); |
| 480 |
}); |
| 481 |
|
| 482 |
// Streaming-aware exception handler, mirrors the error handler above. |
| 483 |
set_exception_handler(function ($e) { |
| 484 |
global $streaming_context; |
| 485 |
|
| 486 |
$error = [ |
| 487 |
"error" => get_class($e) . ": " . $e->getMessage(), |
| 488 |
"file" => $e->getFile(), |
| 489 |
"line" => $e->getLine(), |
| 490 |
"trace" => $e->getTraceAsString(), |
| 491 |
]; |
| 492 |
error_log("Export exception: " . json_encode($error)); |
| 493 |
|
| 494 |
if ($streaming_context !== null) { |
| 495 |
emit_error_chunk( |
| 496 |
$streaming_context['gz'], |
| 497 |
$streaming_context['boundary'], |
| 498 |
get_class($e) . ": " . $e->getMessage() |
| 499 |
); |
| 500 |
return; |
| 501 |
} |
| 502 |
|
| 503 |
http_response_code(500); |
| 504 |
header("Content-Type: application/json"); |
| 505 |
echo json_encode($error); |
| 506 |
exit(1); |
| 507 |
}); |
| 508 |
|
| 509 |
// Catches E_ERROR/E_PARSE fatals that set_error_handler cannot intercept. |
| 510 |
register_shutdown_function(function () { |
| 511 |
global $streaming_context; |
| 512 |
|
| 513 |
$error = error_get_last(); |
| 514 |
if ($error === null) { |
| 515 |
return; |
| 516 |
} |
| 517 |
$fatal_types = E_ERROR | E_PARSE | E_CORE_ERROR | E_COMPILE_ERROR; |
| 518 |
if (!($error['type'] & $fatal_types)) { |
| 519 |
return; |
| 520 |
} |
| 521 |
|
| 522 |
$message = "Fatal: {$error['message']} in {$error['file']}:{$error['line']}"; |
| 523 |
error_log("Export fatal: " . json_encode($error)); |
| 524 |
|
| 525 |
if ($streaming_context !== null) { |
| 526 |
// Best-effort attempt to emit an error chunk into the stream. |
| 527 |
// The stream may already be in a broken state, but this gives |
| 528 |
// the client the best chance of receiving structured error info. |
| 529 |
try { |
| 530 |
emit_error_chunk( |
| 531 |
$streaming_context['gz'], |
| 532 |
$streaming_context['boundary'], |
| 533 |
$message |
| 534 |
); |
| 535 |
} catch (Exception $ignored) { |
| 536 |
// Stream is too broken to write to — nothing more we can do. |
| 537 |
return; |
| 538 |
} catch (Throwable $ignored) { |
| 539 |
// Stream is too broken to write to — nothing more we can do. |
| 540 |
return; |
| 541 |
} |
| 542 |
return; |
| 543 |
} |
| 544 |
|
| 545 |
if (!headers_sent()) { |
| 546 |
http_response_code(500); |
| 547 |
@header("Content-Type: application/json"); |
| 548 |
echo json_encode([ |
| 549 |
"error" => $message, |
| 550 |
"file" => $error['file'], |
| 551 |
"line" => $error['line'], |
| 552 |
"type" => $error['type'], |
| 553 |
]); |
| 554 |
} |
| 555 |
}); |
| 556 |
|
| 557 |
// ============================================================================ |
| 558 |
// E2E Test Hook System (only active when SITE_EXPORT_TEST_MODE env var is set) |
| 559 |
// We don't want anyone to interfere with the export process, which is why those |
| 560 |
// hooks are not registered in production. |
| 561 |
// ============================================================================ |
| 562 |
if (getenv('SITE_EXPORT_TEST_MODE')) { |
| 563 |
/** |
| 564 |
* Load test hooks from a well-known path relative to the site root. |
| 565 |
* The hook file can define callback functions that are called at key |
| 566 |
* points during export for testing error conditions and edge cases. |
| 567 |
* |
| 568 |
* Supported hook functions: |
| 569 |
* test_hook_before_sql_batch(&$sql, $cursor) - Before SQL batch emitted |
| 570 |
* test_hook_before_file_chunk($path, $offset, &$data) - Before file chunk |
| 571 |
* test_hook_after_gzip_init($gz, $boundary) - After gzip stream init |
| 572 |
* test_hook_before_completion($status, $gz, $boundary) - Before completion chunk |
| 573 |
* test_hook_before_index_batch(&$batch_items, $stack) - Before index batch emitted |
| 574 |
* test_hook_during_dir_scan($dir, &$entries) - During directory scanning |
| 575 |
*/ |
| 576 |
$__test_hook_file_loaded = false; |
| 577 |
function _e2e_load_test_hooks_if_needed(array $config): void { |
| 578 |
global $__test_hook_file_loaded; |
| 579 |
if ($__test_hook_file_loaded) { |
| 580 |
return; |
| 581 |
} |
| 582 |
$candidates = []; |
| 583 |
if (isset($config['directory'])) { |
| 584 |
$dirs = is_array($config['directory']) ? $config['directory'] : [$config['directory']]; |
| 585 |
foreach ($dirs as $d) { |
| 586 |
$candidates[] = wp_join_unix_paths( |
| 587 |
$d, |
| 588 |
'wp-content/plugins/site-export/test-hooks.php' |
| 589 |
); |
| 590 |
} |
| 591 |
} |
| 592 |
// Also check relative to this file's parent |
| 593 |
$candidates[] = dirname(__DIR__) . '/test-hooks.php'; |
| 594 |
foreach ($candidates as $candidate) { |
| 595 |
if (file_exists($candidate)) { |
| 596 |
if (function_exists('opcache_invalidate')) { |
| 597 |
@opcache_invalidate($candidate, true); |
| 598 |
} |
| 599 |
require $candidate; |
| 600 |
$__test_hook_file_loaded = true; |
| 601 |
return; |
| 602 |
} |
| 603 |
} |
| 604 |
} |
| 605 |
|
| 606 |
function _e2e_call_hook(string $name, array &$args = []): void { |
| 607 |
if (function_exists($name)) { |
| 608 |
call_user_func_array($name, $args); |
| 609 |
} |
| 610 |
} |
| 611 |
} |
| 612 |
|
| 613 |
require_once __DIR__ . "/class-mysql-dump-producer.php"; |
| 614 |
require_once __DIR__ . "/class-file-tree-producer.php"; |
| 615 |
|
| 616 |
/** |
| 617 |
* Prepares the PHP environment for streaming by disabling output buffering, |
| 618 |
* compression layers, and proxy buffering. |
| 619 |
*/ |
| 620 |
function prepare_streaming_response(): void |
| 621 |
{ |
| 622 |
while (ob_get_level() > 0) { |
| 623 |
@ob_end_clean(); |
| 624 |
} |
| 625 |
|
| 626 |
if (!headers_sent()) { |
| 627 |
@header("X-Accel-Buffering: no"); |
| 628 |
@header("Cache-Control: no-store, no-cache, must-revalidate, max-age=0"); |
| 629 |
@header("Pragma: no-cache"); |
| 630 |
@header("Expires: 0"); |
| 631 |
} |
| 632 |
|
| 633 |
/** |
| 634 |
* zlib.output_compression buffers the entire response before compressing. The |
| 635 |
* entire point of this plugin is to stream the response, therefore we use a custom |
| 636 |
* GzipOutputStream. |
| 637 |
*/ |
| 638 |
if (function_exists("ini_set")) { |
| 639 |
@ini_set("zlib.output_compression", "0"); |
| 640 |
@ini_set("output_buffering", "0"); |
| 641 |
@ini_set("implicit_flush", "1"); |
| 642 |
} |
| 643 |
|
| 644 |
@ob_implicit_flush(true); |
| 645 |
} |
| 646 |
|
| 647 |
/** |
| 648 |
* Deduplicates and resolves a list of paths, discarding empty entries. |
| 649 |
*/ |
| 650 |
function normalize_path_list(array $paths): array |
| 651 |
{ |
| 652 |
$normalized = []; |
| 653 |
foreach ($paths as $path) { |
| 654 |
if (!is_string($path)) { |
| 655 |
continue; |
| 656 |
} |
| 657 |
$path = trim($path); |
| 658 |
if ($path === "") { |
| 659 |
continue; |
| 660 |
} |
| 661 |
$real = realpath($path); |
| 662 |
$final = $real !== false ? $real : $path; |
| 663 |
$final = trim_right_slash($final); |
| 664 |
if ($final === "") { |
| 665 |
continue; |
| 666 |
} |
| 667 |
$normalized[$final] = true; |
| 668 |
} |
| 669 |
return array_keys($normalized); |
| 670 |
} |
| 671 |
|
| 672 |
/** |
| 673 |
* Walks parent directories upward from each start path to find WordPress installations. |
| 674 |
*/ |
| 675 |
function detect_wp_roots(array $start_paths): array |
| 676 |
{ |
| 677 |
$start_paths = normalize_path_list($start_paths); |
| 678 |
$seen = []; |
| 679 |
$roots = []; |
| 680 |
|
| 681 |
foreach ($start_paths as $start) { |
| 682 |
$current = $start; |
| 683 |
while ($current !== "" && !isset($seen[$current])) { |
| 684 |
$seen[$current] = true; |
| 685 |
$wp_load_path = wp_join_unix_paths($current, "wp-load.php"); |
| 686 |
$wp_config_path = wp_join_unix_paths($current, "wp-config.php"); |
| 687 |
$wp_content_path = wp_join_unix_paths($current, "wp-content"); |
| 688 |
$filesystem_probe_warning = false; |
| 689 |
$reprint_error_handler = null; |
| 690 |
// During preflight, Reprint's error handler turns a warning into HTTP 500. |
| 691 |
// These checks move up to parent directories that open_basedir may block. |
| 692 |
// Catch probe warnings here so we can stop only this walk. Send other error |
| 693 |
// types to the previous handler, then restore that handler in finally below. |
| 694 |
$reprint_error_handler = set_error_handler( |
| 695 |
function ($errno, $errstr, $errfile, $errline) use ( |
| 696 |
&$filesystem_probe_warning, |
| 697 |
&$reprint_error_handler |
| 698 |
) { |
| 699 |
if ($errno === E_WARNING) { |
| 700 |
$filesystem_probe_warning = true; |
| 701 |
return true; |
| 702 |
} |
| 703 |
if (!is_callable($reprint_error_handler)) { |
| 704 |
return false; |
| 705 |
} |
| 706 |
return call_user_func( |
| 707 |
$reprint_error_handler, |
| 708 |
$errno, |
| 709 |
$errstr, |
| 710 |
$errfile, |
| 711 |
$errline |
| 712 |
); |
| 713 |
} |
| 714 |
); |
| 715 |
try { |
| 716 |
$has_wp_load = file_exists($wp_load_path); |
| 717 |
$has_wp_config = file_exists($wp_config_path); |
| 718 |
$has_wp_content = is_dir($wp_content_path); |
| 719 |
} finally { |
| 720 |
restore_error_handler(); |
| 721 |
} |
| 722 |
if ($filesystem_probe_warning) { |
| 723 |
// WordPress root discovery is speculative. If this path cannot be |
| 724 |
// inspected reliably, keep roots found by this walk and let |
| 725 |
// preflight continue with the other start paths. |
| 726 |
break; |
| 727 |
} |
| 728 |
if ($has_wp_load || $has_wp_config) { |
| 729 |
$roots[$current] = [ |
| 730 |
"path" => $current, |
| 731 |
"wp_load" => $has_wp_load, |
| 732 |
"wp_load_path" => $has_wp_load ? $wp_load_path : null, |
| 733 |
"wp_config" => $has_wp_config, |
| 734 |
"wp_config_path" => $has_wp_config ? $wp_config_path : null, |
| 735 |
"wp_content" => $has_wp_content, |
| 736 |
]; |
| 737 |
} |
| 738 |
|
| 739 |
$parent = dirname($current); |
| 740 |
if ($parent === $current || $parent === "") { |
| 741 |
break; |
| 742 |
} |
| 743 |
$current = $parent; |
| 744 |
} |
| 745 |
} |
| 746 |
|
| 747 |
return [ |
| 748 |
"searched" => array_keys($seen), |
| 749 |
"roots" => array_values($roots), |
| 750 |
]; |
| 751 |
} |
| 752 |
|
| 753 |
/** |
| 754 |
* Streams SQL dump fragments as gzipped multipart chunks. |
| 755 |
*/ |
| 756 |
function endpoint_sql_chunk( |
| 757 |
array $config, |
| 758 |
ResourceBudget $budget |
| 759 |
): array { |
| 760 |
prepare_streaming_response(); |
| 761 |
$creds = resolve_db_credentials(); |
| 762 |
|
| 763 |
// -- Parse request parameters -- |
| 764 |
$fragments_per_batch = $config["fragments_per_batch"] ?? 1000; |
| 765 |
$fragments_per_batch = require_int_range( |
| 766 |
"fragments_per_batch", |
| 767 |
(int) $fragments_per_batch, |
| 768 |
1, |
| 769 |
10000 |
| 770 |
); |
| 771 |
|
| 772 |
$pdo_options = []; |
| 773 |
if (!empty($config["db_unbuffered"]) && extension_loaded('pdo_mysql')) { |
| 774 |
$pdo_options[PDO::MYSQL_ATTR_USE_BUFFERED_QUERY] = false; |
| 775 |
} |
| 776 |
$mysql = create_db_connection($creds, $pdo_options); |
| 777 |
|
| 778 |
$producer_options = [ |
| 779 |
"create_table_query" => $config["create_table_query"] ?? true, |
| 780 |
]; |
| 781 |
|
| 782 |
// -- Cap statement size to packet limits -- |
| 783 |
// If the client sent its max_allowed_packet, cap the producer's |
| 784 |
// max_statement_size so the dump stays importable on the client. |
| 785 |
// We query the server's own max_allowed_packet too and use the |
| 786 |
// smaller of the two (both scaled to 80% for protocol headroom). |
| 787 |
if (!empty($config["max_allowed_packet"])) { |
| 788 |
$client_max = (int) $config["max_allowed_packet"]; |
| 789 |
if ($client_max >= 1048576 && $client_max <= 1073741824) { |
| 790 |
$client_statement_size = (int) ($client_max * 0.8); |
| 791 |
$server_statement_size = null; |
| 792 |
try { |
| 793 |
$row = $mysql |
| 794 |
->query("SELECT @@max_allowed_packet AS v") |
| 795 |
->fetch(PdoConstants::fetch_assoc()); |
| 796 |
if ($row && isset($row["v"])) { |
| 797 |
$server_statement_size = (int) ((int) $row["v"] * 0.8); |
| 798 |
} |
| 799 |
} catch (Exception $e) { |
| 800 |
// Ignore — producer will auto-detect |
| 801 |
} |
| 802 |
if ($server_statement_size !== null) { |
| 803 |
$producer_options["max_statement_size"] = min( |
| 804 |
$client_statement_size, |
| 805 |
$server_statement_size |
| 806 |
); |
| 807 |
} else { |
| 808 |
$producer_options["max_statement_size"] = $client_statement_size; |
| 809 |
} |
| 810 |
} |
| 811 |
} |
| 812 |
|
| 813 |
if (!empty($config["db_query_time_limit"])) { |
| 814 |
$execution_budget_ms = (int) ($budget->max_time * 1000 * 0.8); |
| 815 |
$query_time_limit = require_int_range( |
| 816 |
"db_query_time_limit", |
| 817 |
(int) $config["db_query_time_limit"], |
| 818 |
0, |
| 819 |
300000 |
| 820 |
); |
| 821 |
$query_time_limit = min($query_time_limit, $execution_budget_ms); |
| 822 |
if ($query_time_limit > 0) { |
| 823 |
$producer_options["query_time_limit_ms"] = $query_time_limit; |
| 824 |
} |
| 825 |
} |
| 826 |
|
| 827 |
$exclude_rows = sql_exclude_rows_from_config($config, $creds["table_prefix"] ?? null); |
| 828 |
if ($exclude_rows) { |
| 829 |
$producer_options["exclude_rows"] = $exclude_rows; |
| 830 |
} |
| 831 |
|
| 832 |
if (isset($config["skip_tables"])) { |
| 833 |
if (!is_array($config["skip_tables"])) { |
| 834 |
throw new InvalidArgumentException("skip_tables must be an array"); |
| 835 |
} |
| 836 |
foreach ($config["skip_tables"] as $skipped_table) { |
| 837 |
if (!is_string($skipped_table) || $skipped_table === "") { |
| 838 |
throw new InvalidArgumentException( |
| 839 |
"Every skip_tables entry must be a non-empty string" |
| 840 |
); |
| 841 |
} |
| 842 |
} |
| 843 |
$producer_options["exclude_tables"] = array_values($config["skip_tables"]); |
| 844 |
} |
| 845 |
|
| 846 |
if (isset($config["cursor"])) { |
| 847 |
$producer_options["cursor"] = $config["cursor"]; |
| 848 |
} |
| 849 |
|
| 850 |
$reader = new MySQLDumpProducer( |
| 851 |
$mysql, |
| 852 |
$producer_options |
| 853 |
); |
| 854 |
|
| 855 |
if (ob_get_level()) { |
| 856 |
ob_end_flush(); |
| 857 |
} |
| 858 |
|
| 859 |
|
| 860 |
['gz' => $gz, 'boundary' => $boundary] = begin_multipart_stream(true); |
| 861 |
|
| 862 |
// E2E test hook: after gzip stream initialization |
| 863 |
if (getenv('SITE_EXPORT_TEST_MODE')) { |
| 864 |
_e2e_load_test_hooks_if_needed($config); |
| 865 |
$hook_args = [$gz, $boundary]; |
| 866 |
_e2e_call_hook('test_hook_after_gzip_init', $hook_args); |
| 867 |
} |
| 868 |
|
| 869 |
if (!isset($config["cursor"])) { |
| 870 |
// Send the initial connection settings separately so the client can save |
| 871 |
// them outside db.sql for a later MySQL connection. |
| 872 |
$session_setup = MySQLDumpProducer::get_session_setup_sql(); |
| 873 |
$gz->write( |
| 874 |
"--{$boundary}\r\n" . |
| 875 |
"Content-Type: application/sql\r\n" . |
| 876 |
"Content-Length: " . strlen($session_setup) . "\r\n" . |
| 877 |
"X-Chunk-Type: sql_session_setup\r\n" . |
| 878 |
"\r\n" |
| 879 |
); |
| 880 |
$gz->write($session_setup); |
| 881 |
$gz->write("\r\n"); |
| 882 |
$gz->sync(); |
| 883 |
} |
| 884 |
|
| 885 |
// -- Stream SQL fragments -- |
| 886 |
// Pull SQL fragments from the producer in batches, writing each batch |
| 887 |
// as one or two multipart parts. Stop when the producer is exhausted or the |
| 888 |
// resource budget (time/memory) runs out. |
| 889 |
$batches_processed = 0; |
| 890 |
$sql_bytes_processed = 0; |
| 891 |
$aborted = false; |
| 892 |
/** @var string|null $deferred_fragment */ |
| 893 |
$deferred_fragment = null; |
| 894 |
/** @var string|null $deferred_fragment_cursor */ |
| 895 |
$deferred_fragment_cursor = null; |
| 896 |
/** @var bool $deferred_fragment_must_be_its_own_part */ |
| 897 |
$deferred_fragment_must_be_its_own_part = false; |
| 898 |
|
| 899 |
$stream_failure = null; |
| 900 |
try { |
| 901 |
while ( |
| 902 |
$budget->has_remaining() |
| 903 |
) { |
| 904 |
$sql_fragments = []; |
| 905 |
$sql_batch_bytes = 0; |
| 906 |
$cursor = null; |
| 907 |
/** @var string|null Cursor after the last fragment included in this batch. */ |
| 908 |
$last_fragment_cursor = null; |
| 909 |
$sql_ends_with_complete_statement = false; |
| 910 |
$complete_prefix_byte_length = 0; |
| 911 |
/** @var string|null Cursor after the last complete statement in this batch. */ |
| 912 |
$complete_prefix_cursor = null; |
| 913 |
|
| 914 |
$i = 0; |
| 915 |
$part_must_end = false; |
| 916 |
if ($deferred_fragment !== null) { |
| 917 |
$sql_fragments[] = $deferred_fragment; |
| 918 |
$sql_batch_bytes = strlen($deferred_fragment); |
| 919 |
$cursor = $deferred_fragment_cursor; |
| 920 |
$last_fragment_cursor = $deferred_fragment_cursor; |
| 921 |
$trimmed_fragment = rtrim($deferred_fragment); |
| 922 |
$sql_ends_with_complete_statement = |
| 923 |
$trimmed_fragment !== '' && substr($trimmed_fragment, -1) === ';'; |
| 924 |
if ($sql_ends_with_complete_statement) { |
| 925 |
$complete_prefix_byte_length = $sql_batch_bytes; |
| 926 |
$complete_prefix_cursor = $deferred_fragment_cursor; |
| 927 |
} |
| 928 |
$part_must_end = $deferred_fragment_must_be_its_own_part; |
| 929 |
$i = 1; |
| 930 |
$deferred_fragment = null; |
| 931 |
$deferred_fragment_cursor = null; |
| 932 |
$deferred_fragment_must_be_its_own_part = false; |
| 933 |
} |
| 934 |
|
| 935 |
if ( |
| 936 |
!$part_must_end && |
| 937 |
$i < $fragments_per_batch |
| 938 |
) { |
| 939 |
while ($reader->next_sql_fragment()) { |
| 940 |
$fragment = (string) $reader->get_sql_fragment(); |
| 941 |
$fragment_bytes = strlen($fragment); |
| 942 |
|
| 943 |
if ( |
| 944 |
$fragment_bytes > MySQLDumpProducer::MAX_SQL_PART_BODY_BYTES |
| 945 |
) { |
| 946 |
throw new RuntimeException( |
| 947 |
"The SQL producer returned a {$fragment_bytes}-byte fragment; " . |
| 948 |
"the decoded SQL part body limit is " . |
| 949 |
MySQLDumpProducer::MAX_SQL_PART_BODY_BYTES . |
| 950 |
" bytes." |
| 951 |
); |
| 952 |
} |
| 953 |
$fragment_cursor = $reader->get_reentrancy_cursor(); |
| 954 |
|
| 955 |
if ( |
| 956 |
!empty($sql_fragments) && |
| 957 |
$sql_batch_bytes + $fragment_bytes > |
| 958 |
MySQLDumpProducer::MAX_SQL_PART_BODY_BYTES |
| 959 |
) { |
| 960 |
// The producer has already advanced. Retain this fragment |
| 961 |
// and its cursor while this batch keeps its earlier cursor. |
| 962 |
$deferred_fragment = $fragment; |
| 963 |
$deferred_fragment_cursor = $fragment_cursor; |
| 964 |
$deferred_fragment_must_be_its_own_part = |
| 965 |
$reader->current_fragment_must_be_its_own_part(); |
| 966 |
break; |
| 967 |
} |
| 968 |
|
| 969 |
// The importer stores a cursor only after executing a complete part. |
| 970 |
// Keep the SET header alone before row data. Do not put DROP/CREATE |
| 971 |
// or the footer after INSERTs: their implicit or explicit COMMIT |
| 972 |
// could make those rows permanent before the INSERT cursor is stored. |
| 973 |
// Keep each CONCAT UPDATE alone so its cursor is stored immediately; |
| 974 |
// if MyISAM stops first, the importer refuses to repeat the append. |
| 975 |
if ( |
| 976 |
$reader->current_fragment_must_be_its_own_part() && |
| 977 |
!empty($sql_fragments) && |
| 978 |
$sql_ends_with_complete_statement |
| 979 |
) { |
| 980 |
$deferred_fragment = $fragment; |
| 981 |
$deferred_fragment_cursor = $fragment_cursor; |
| 982 |
$deferred_fragment_must_be_its_own_part = true; |
| 983 |
break; |
| 984 |
} |
| 985 |
|
| 986 |
$sql_fragments[] = $fragment; |
| 987 |
$sql_batch_bytes += $fragment_bytes; |
| 988 |
$last_fragment_cursor = $fragment_cursor; |
| 989 |
$i++; |
| 990 |
|
| 991 |
$trimmed_fragment = rtrim($fragment); |
| 992 |
$sql_ends_with_complete_statement = |
| 993 |
$trimmed_fragment !== '' && substr($trimmed_fragment, -1) === ';'; |
| 994 |
if ($sql_ends_with_complete_statement) { |
| 995 |
$cursor = $fragment_cursor; |
| 996 |
$complete_prefix_byte_length = $sql_batch_bytes; |
| 997 |
$complete_prefix_cursor = $fragment_cursor; |
| 998 |
} |
| 999 |
|
| 1000 |
if ($reader->current_fragment_must_be_its_own_part()) { |
| 1001 |
break; |
| 1002 |
} |
| 1003 |
|
| 1004 |
if ($i >= $fragments_per_batch) { |
| 1005 |
break; |
| 1006 |
} |
| 1007 |
|
| 1008 |
if ( |
| 1009 |
!$budget->has_remaining() |
| 1010 |
) { |
| 1011 |
break; |
| 1012 |
} |
| 1013 |
} |
| 1014 |
} |
| 1015 |
|
| 1016 |
$sql = implode("", $sql_fragments); |
| 1017 |
if ($sql === '') { |
| 1018 |
break; |
| 1019 |
} |
| 1020 |
// Does this assembled SQL body end on a complete statement boundary? |
| 1021 |
// A complete SQL statement ends with ";"; a fragment from an open |
| 1022 |
// INSERT does not. |
| 1023 |
$query_complete = $sql_ends_with_complete_statement; |
| 1024 |
if (!$query_complete || $cursor === null) { |
| 1025 |
$cursor = $last_fragment_cursor; |
| 1026 |
} |
| 1027 |
|
| 1028 |
// E2E test hook: before SQL batch is emitted |
| 1029 |
if (getenv('SITE_EXPORT_TEST_MODE')) { |
| 1030 |
$hook_args = [&$sql, $cursor]; |
| 1031 |
_e2e_call_hook('test_hook_before_sql_batch', $hook_args); |
| 1032 |
} |
| 1033 |
|
| 1034 |
$sql_batch_bytes = strlen($sql); |
| 1035 |
if ( |
| 1036 |
$sql_batch_bytes > MySQLDumpProducer::MAX_SQL_PART_BODY_BYTES |
| 1037 |
) { |
| 1038 |
throw new RuntimeException( |
| 1039 |
"The decoded SQL part body is {$sql_batch_bytes} bytes; " . |
| 1040 |
"the limit is " . |
| 1041 |
MySQLDumpProducer::MAX_SQL_PART_BODY_BYTES . |
| 1042 |
" bytes." |
| 1043 |
); |
| 1044 |
} |
| 1045 |
$sql_bytes_processed += $sql_batch_bytes; |
| 1046 |
// Keep only the assembled bounded batch while it is split and emitted. |
| 1047 |
unset($sql_fragments); |
| 1048 |
|
| 1049 |
if ( |
| 1050 |
!$query_complete |
| 1051 |
&& $complete_prefix_byte_length > 0 |
| 1052 |
&& $complete_prefix_cursor !== null |
| 1053 |
) { |
| 1054 |
// Expose the last complete statement boundary before the |
| 1055 |
// incomplete suffix. The importer can save that cursor instead |
| 1056 |
// of retaining earlier statements with the suffix. |
| 1057 |
$complete_sql_prefix = substr($sql, 0, $complete_prefix_byte_length); |
| 1058 |
$gz->write( |
| 1059 |
"--{$boundary}\r\n" . |
| 1060 |
"Content-Type: application/sql\r\n" . |
| 1061 |
"Content-Length: " . strlen($complete_sql_prefix) . "\r\n" . |
| 1062 |
"X-Chunk-Type: sql\r\n" . |
| 1063 |
"X-Query-Complete: 1\r\n" . |
| 1064 |
"X-Cursor: " . base64_encode($complete_prefix_cursor) . "\r\n" . |
| 1065 |
"\r\n" |
| 1066 |
); |
| 1067 |
$gz->write($complete_sql_prefix); |
| 1068 |
$gz->write("\r\n"); |
| 1069 |
$gz->sync(); |
| 1070 |
unset($complete_sql_prefix); |
| 1071 |
|
| 1072 |
$sql = substr($sql, $complete_prefix_byte_length); |
| 1073 |
} |
| 1074 |
|
| 1075 |
$gz->write( |
| 1076 |
"--{$boundary}\r\n" . |
| 1077 |
"Content-Type: application/sql\r\n" . |
| 1078 |
"Content-Length: " . strlen($sql) . "\r\n" . |
| 1079 |
"X-Chunk-Type: sql\r\n" . |
| 1080 |
"X-Query-Complete: " . ($query_complete ? "1" : "0") . "\r\n" . |
| 1081 |
"X-Cursor: " . base64_encode($cursor) . "\r\n" . |
| 1082 |
"\r\n" |
| 1083 |
); |
| 1084 |
$gz->write($sql); |
| 1085 |
$gz->write("\r\n"); |
| 1086 |
$gz->sync(); |
| 1087 |
|
| 1088 |
$batches_processed++; |
| 1089 |
|
| 1090 |
if ($reader->is_finished() && $deferred_fragment === null) { |
| 1091 |
break; |
| 1092 |
} |
| 1093 |
} |
| 1094 |
} catch (Exception $e) { |
| 1095 |
$stream_failure = $e; |
| 1096 |
} catch (Throwable $e) { |
| 1097 |
$stream_failure = $e; |
| 1098 |
} |
| 1099 |
|
| 1100 |
if ($stream_failure !== null) { |
| 1101 |
$aborted = true; |
| 1102 |
error_log("SQL streaming error: " . $stream_failure->getMessage()); |
| 1103 |
emit_error_chunk($gz, $boundary, $stream_failure->getMessage()); |
| 1104 |
} |
| 1105 |
|
| 1106 |
// Best-effort completion chunk — the client already has the data chunks. |
| 1107 |
$status = $aborted |
| 1108 |
? "partial" |
| 1109 |
: ($reader->is_finished() && $deferred_fragment === null ? "complete" : "partial"); |
| 1110 |
|
| 1111 |
// E2E test hook: before completion chunk |
| 1112 |
if (getenv('SITE_EXPORT_TEST_MODE')) { |
| 1113 |
$hook_args = [$status, $gz, $boundary]; |
| 1114 |
_e2e_call_hook('test_hook_before_completion', $hook_args); |
| 1115 |
} |
| 1116 |
|
| 1117 |
$completion_failure = null; |
| 1118 |
try { |
| 1119 |
$gz->write( |
| 1120 |
"--{$boundary}\r\n" . |
| 1121 |
"Content-Type: application/octet-stream\r\n" . |
| 1122 |
"Content-Length: 0\r\n" . |
| 1123 |
"X-Chunk-Type: completion\r\n" . |
| 1124 |
"X-Status: {$status}\r\n" . |
| 1125 |
"X-Batches-Processed: {$batches_processed}\r\n" . |
| 1126 |
"X-SQL-Bytes: {$sql_bytes_processed}\r\n" . |
| 1127 |
"X-Memory-Used: " . memory_get_peak_usage(true) . "\r\n" . |
| 1128 |
"X-Memory-Limit: " . $budget->max_memory . "\r\n" . |
| 1129 |
"X-Time-Elapsed: " . (microtime(true) - $budget->start_time) . "\r\n" . |
| 1130 |
"\r\n" . |
| 1131 |
"\r\n" . |
| 1132 |
"--{$boundary}--\r\n" |
| 1133 |
); |
| 1134 |
$gz->finish(); |
| 1135 |
} catch (\Exception $e) { |
| 1136 |
$completion_failure = $e; |
| 1137 |
} catch (\Throwable $e) { |
| 1138 |
$completion_failure = $e; |
| 1139 |
} |
| 1140 |
if ($completion_failure !== null) { |
| 1141 |
error_log("Export: failed to write completion chunk: " . $completion_failure->getMessage()); |
| 1142 |
} |
| 1143 |
|
| 1144 |
return [ |
| 1145 |
"status" => $status, |
| 1146 |
"stats" => [ |
| 1147 |
"batches_processed" => $batches_processed, |
| 1148 |
"sql_bytes" => $sql_bytes_processed, |
| 1149 |
"memory_used" => memory_get_peak_usage(true), |
| 1150 |
"time_elapsed" => microtime(true) - $budget->start_time, |
| 1151 |
], |
| 1152 |
]; |
| 1153 |
} |
| 1154 |
|
| 1155 |
/** |
| 1156 |
* Streams table metadata (name, estimated rows, size) from INFORMATION_SCHEMA. |
| 1157 |
*/ |
| 1158 |
function endpoint_db_index( |
| 1159 |
array $config, |
| 1160 |
ResourceBudget $budget |
| 1161 |
): array { |
| 1162 |
prepare_streaming_response(); |
| 1163 |
|
| 1164 |
$creds = resolve_db_credentials(); |
| 1165 |
|
| 1166 |
if (getenv('SITE_EXPORT_TEST_MODE')) { |
| 1167 |
_e2e_load_test_hooks_if_needed($config); |
| 1168 |
} |
| 1169 |
|
| 1170 |
$tables_per_batch = $config["tables_per_batch"] ?? 1000; |
| 1171 |
$tables_per_batch = require_int_range( |
| 1172 |
"tables_per_batch", |
| 1173 |
(int) $tables_per_batch, |
| 1174 |
10, |
| 1175 |
10000 |
| 1176 |
); |
| 1177 |
|
| 1178 |
$cursor = null; |
| 1179 |
if (isset($config["cursor"])) { |
| 1180 |
$cursor = json_decode($config["cursor"], true); |
| 1181 |
if ($cursor === null && json_last_error() !== JSON_ERROR_NONE) { |
| 1182 |
throw new InvalidArgumentException( |
| 1183 |
"Invalid cursor format: " . json_last_error_msg() |
| 1184 |
); |
| 1185 |
} |
| 1186 |
} |
| 1187 |
$last_table = $cursor["last_table"] ?? ""; |
| 1188 |
|
| 1189 |
$mysql = create_db_connection($creds); |
| 1190 |
|
| 1191 |
['gz' => $gz, 'boundary' => $boundary] = begin_multipart_stream(); |
| 1192 |
|
| 1193 |
$tables_processed = 0; |
| 1194 |
$rows_estimated = 0; |
| 1195 |
$status = "partial"; |
| 1196 |
$aborted = false; |
| 1197 |
|
| 1198 |
$stream_failure = null; |
| 1199 |
try { |
| 1200 |
while ( |
| 1201 |
$budget->has_remaining() |
| 1202 |
) { |
| 1203 |
$sql = |
| 1204 |
"SELECT TABLE_NAME, TABLE_ROWS, DATA_LENGTH, INDEX_LENGTH, ENGINE, " . |
| 1205 |
"TABLE_COLLATION FROM INFORMATION_SCHEMA.TABLES " . |
| 1206 |
"WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME > :last " . |
| 1207 |
"ORDER BY TABLE_NAME ASC LIMIT {$tables_per_batch}"; |
| 1208 |
$stmt = $mysql->prepare($sql); |
| 1209 |
$stmt->bindValue(":last", $last_table, PdoConstants::param_str()); |
| 1210 |
$stmt->execute(); |
| 1211 |
$rows = $stmt->fetchAll(PdoConstants::fetch_assoc()); |
| 1212 |
|
| 1213 |
if (!$rows) { |
| 1214 |
$status = "complete"; |
| 1215 |
break; |
| 1216 |
} |
| 1217 |
|
| 1218 |
$tables = []; |
| 1219 |
foreach ($rows as $row) { |
| 1220 |
$name = (string) ($row["TABLE_NAME"] ?? ""); |
| 1221 |
$tables[] = [ |
| 1222 |
"name" => $name, |
| 1223 |
"rows" => |
| 1224 |
isset($row["TABLE_ROWS"]) && is_numeric($row["TABLE_ROWS"]) |
| 1225 |
? (int) $row["TABLE_ROWS"] |
| 1226 |
: null, |
| 1227 |
"data_bytes" => |
| 1228 |
isset($row["DATA_LENGTH"]) && is_numeric($row["DATA_LENGTH"]) |
| 1229 |
? (int) $row["DATA_LENGTH"] |
| 1230 |
: null, |
| 1231 |
"index_bytes" => |
| 1232 |
isset($row["INDEX_LENGTH"]) && is_numeric($row["INDEX_LENGTH"]) |
| 1233 |
? (int) $row["INDEX_LENGTH"] |
| 1234 |
: null, |
| 1235 |
"engine" => $row["ENGINE"] ?? null, |
| 1236 |
"collation" => $row["TABLE_COLLATION"] ?? null, |
| 1237 |
]; |
| 1238 |
$last_table = $name; |
| 1239 |
$tables_processed++; |
| 1240 |
if ( |
| 1241 |
isset($row["TABLE_ROWS"]) && |
| 1242 |
is_numeric($row["TABLE_ROWS"]) |
| 1243 |
) { |
| 1244 |
$rows_estimated += (int) $row["TABLE_ROWS"]; |
| 1245 |
} |
| 1246 |
} |
| 1247 |
|
| 1248 |
$payload = json_encode_or_throw($tables); |
| 1249 |
$cursor_json = json_encode_or_throw([ |
| 1250 |
"phase" => "tables", |
| 1251 |
"last_table" => $last_table, |
| 1252 |
]); |
| 1253 |
|
| 1254 |
$gz->write( |
| 1255 |
"--{$boundary}\r\n" . |
| 1256 |
"Content-Type: application/json\r\n" . |
| 1257 |
"Content-Length: " . strlen($payload) . "\r\n" . |
| 1258 |
"X-Chunk-Type: table_stats\r\n" . |
| 1259 |
"X-Tables: " . count($tables) . "\r\n" . |
| 1260 |
"X-Cursor: " . base64_encode($cursor_json) . "\r\n" . |
| 1261 |
"\r\n" . |
| 1262 |
$payload . "\r\n" |
| 1263 |
); |
| 1264 |
$gz->sync(); |
| 1265 |
|
| 1266 |
if (count($rows) < $tables_per_batch) { |
| 1267 |
$status = "complete"; |
| 1268 |
break; |
| 1269 |
} |
| 1270 |
} |
| 1271 |
} catch (\Exception $e) { |
| 1272 |
$stream_failure = $e; |
| 1273 |
} catch (\Throwable $e) { |
| 1274 |
$stream_failure = $e; |
| 1275 |
} |
| 1276 |
|
| 1277 |
if ($stream_failure !== null) { |
| 1278 |
$aborted = true; |
| 1279 |
emit_error_chunk( |
| 1280 |
$gz, |
| 1281 |
$boundary, |
| 1282 |
get_class($stream_failure) . ": " . $stream_failure->getMessage() |
| 1283 |
); |
| 1284 |
} |
| 1285 |
|
| 1286 |
$completion_failure = null; |
| 1287 |
try { |
| 1288 |
if (getenv('SITE_EXPORT_TEST_MODE')) { |
| 1289 |
$hook_status = $aborted ? "partial" : $status; |
| 1290 |
$hook_args = [$hook_status, $gz, $boundary]; |
| 1291 |
_e2e_call_hook('test_hook_before_completion', $hook_args); |
| 1292 |
} |
| 1293 |
|
| 1294 |
$gz->write( |
| 1295 |
"--{$boundary}\r\n" . |
| 1296 |
"Content-Type: application/octet-stream\r\n" . |
| 1297 |
"Content-Length: 0\r\n" . |
| 1298 |
"X-Chunk-Type: completion\r\n" . |
| 1299 |
"X-Status: " . ($aborted ? "partial" : $status) . "\r\n" . |
| 1300 |
"X-Tables-Processed: {$tables_processed}\r\n" . |
| 1301 |
"X-Rows-Estimated: {$rows_estimated}\r\n" . |
| 1302 |
"X-Memory-Used: " . memory_get_peak_usage(true) . "\r\n" . |
| 1303 |
"X-Memory-Limit: " . $budget->max_memory . "\r\n" . |
| 1304 |
"X-Time-Elapsed: " . (microtime(true) - $budget->start_time) . "\r\n" . |
| 1305 |
"\r\n" . |
| 1306 |
"\r\n" . |
| 1307 |
"--{$boundary}--\r\n" |
| 1308 |
); |
| 1309 |
$gz->finish(); |
| 1310 |
} catch (\Exception $e) { |
| 1311 |
$completion_failure = $e; |
| 1312 |
} catch (\Throwable $e) { |
| 1313 |
$completion_failure = $e; |
| 1314 |
} |
| 1315 |
if ($completion_failure !== null) { |
| 1316 |
error_log("Export: failed to write completion chunk: " . $completion_failure->getMessage()); |
| 1317 |
} |
| 1318 |
|
| 1319 |
return [ |
| 1320 |
"status" => $status, |
| 1321 |
"stats" => [ |
| 1322 |
"tables_processed" => $tables_processed, |
| 1323 |
"rows_estimated" => $rows_estimated, |
| 1324 |
"memory_used" => memory_get_peak_usage(true), |
| 1325 |
"time_elapsed" => microtime(true) - $budget->start_time, |
| 1326 |
], |
| 1327 |
]; |
| 1328 |
} |
| 1329 |
|
| 1330 |
/** |
| 1331 |
* Resolves directory paths from config for operations which can walk only directories. |
| 1332 |
*/ |
| 1333 |
function resolve_directories(array $config): array |
| 1334 |
{ |
| 1335 |
$directories_input = $config["directory"] ?? null; |
| 1336 |
if (!$directories_input) { |
| 1337 |
throw new InvalidArgumentException( |
| 1338 |
"directory is required for files operation" |
| 1339 |
); |
| 1340 |
} |
| 1341 |
|
| 1342 |
$directories = []; |
| 1343 |
$dir_list = is_array($directories_input) |
| 1344 |
? $directories_input |
| 1345 |
: [$directories_input]; |
| 1346 |
|
| 1347 |
foreach ($dir_list as $directory) { |
| 1348 |
if (!is_string($directory)) { |
| 1349 |
throw new InvalidArgumentException( |
| 1350 |
"directory entries must be non-empty strings" |
| 1351 |
); |
| 1352 |
} |
| 1353 |
$directory = trim($directory); |
| 1354 |
assert_valid_path($directory, "directory entry"); |
| 1355 |
|
| 1356 |
clearstatcache(true, $directory); |
| 1357 |
$real_directory = @realpath($directory); |
| 1358 |
if ($real_directory === false || !is_dir($real_directory)) { |
| 1359 |
throw new InvalidArgumentException( |
| 1360 |
"directory entry is not an accessible directory: {$directory}\n" . |
| 1361 |
"Current working directory: " . |
| 1362 |
getcwd() . |
| 1363 |
"\n" . |
| 1364 |
"Script directory: " . |
| 1365 |
__DIR__ |
| 1366 |
); |
| 1367 |
} |
| 1368 |
|
| 1369 |
$directories[] = $real_directory; |
| 1370 |
} |
| 1371 |
|
| 1372 |
if (empty($directories)) { |
| 1373 |
throw new InvalidArgumentException("No valid directories specified"); |
| 1374 |
} |
| 1375 |
|
| 1376 |
return $directories; |
| 1377 |
} |
| 1378 |
|
| 1379 |
/** |
| 1380 |
* Builds file-index roots from the file_index request's `directory` parameter. |
| 1381 |
* |
| 1382 |
* The `directory` parameter contains the selected paths. In spite of the |
| 1383 |
* parameter name, a selected path may name a directory, regular file, or |
| 1384 |
* symlink. |
| 1385 |
* |
| 1386 |
* Unlike resolve_directories(), this keeps one file-index root for every |
| 1387 |
* selected path. `requested_path` is the normalized spelling supplied by the |
| 1388 |
* client. `resolved_path` is its realpath() target. |
| 1389 |
* |
| 1390 |
* FileIndexProcessor adds a link entry at `requested_path` to the file index. |
| 1391 |
* It walks a followed directory target at `resolved_path`. It also uses |
| 1392 |
* `resolved_path` so aliases to the same target are indexed once. |
| 1393 |
* |
| 1394 |
* Example: for /site/theme -> /shared/theme, this returns a file-index root |
| 1395 |
* with `requested_path` /site/theme, `resolved_path` /shared/theme, and type |
| 1396 |
* symlink. With symlink following enabled, it adds the link entry at |
| 1397 |
* /site/theme and indexes the target tree at /shared/theme. |
| 1398 |
* |
| 1399 |
* @return array[] { |
| 1400 |
* File-index roots. |
| 1401 |
* |
| 1402 |
* @type string $requested_path Normalized path supplied by the client. |
| 1403 |
* @type string|null $resolved_path realpath() target, when available. |
| 1404 |
* @type string $type directory, file, symlink, or missing. |
| 1405 |
* } |
| 1406 |
*/ |
| 1407 |
function resolve_file_index_roots(array $config): array |
| 1408 |
{ |
| 1409 |
$roots_input = $config["directory"] ?? null; |
| 1410 |
if (!$roots_input) { |
| 1411 |
throw new InvalidArgumentException("directory is required for files operation"); |
| 1412 |
} |
| 1413 |
|
| 1414 |
$roots = []; |
| 1415 |
foreach (is_array($roots_input) ? $roots_input : [$roots_input] as $root_input) { |
| 1416 |
if (!is_string($root_input)) { |
| 1417 |
throw new InvalidArgumentException("directory entries must be non-empty strings"); |
| 1418 |
} |
| 1419 |
$root_input = trim($root_input); |
| 1420 |
assert_valid_path($root_input, "directory entry"); |
| 1421 |
$requested_path = normalize_path($root_input); |
| 1422 |
clearstatcache(true, $requested_path); |
| 1423 |
$stat = @lstat($requested_path); |
| 1424 |
if ($stat === false) { |
| 1425 |
// The client sends `pulled_before` for selected paths an earlier pull |
| 1426 |
// already saw. Absence there means the source deleted the path, so it |
| 1427 |
// becomes a missing root instead of an error. Anything else absent is |
| 1428 |
// a bad path and still throws below. |
| 1429 |
$paths_pulled_before = isset($config["pulled_before"]) && is_array($config["pulled_before"]) |
| 1430 |
? $config["pulled_before"] |
| 1431 |
: []; |
| 1432 |
if (in_array($requested_path, $paths_pulled_before, true)) { |
| 1433 |
$roots[] = [ |
| 1434 |
"requested_path" => $requested_path, |
| 1435 |
"resolved_path" => null, |
| 1436 |
"type" => "missing", |
| 1437 |
]; |
| 1438 |
continue; |
| 1439 |
} |
| 1440 |
throw new InvalidArgumentException( |
| 1441 |
"Selected file-index root does not exist or is not accessible: {$requested_path}" |
| 1442 |
); |
| 1443 |
} |
| 1444 |
|
| 1445 |
$mode = $stat["mode"] & STAT_TYPE_MASK; |
| 1446 |
$type = $mode === STAT_TYPE_LINK ? "symlink" : ( is_dir($requested_path) ? "directory" : "file" ); |
| 1447 |
$resolved_path = @realpath($requested_path); |
| 1448 |
if ($type === "symlink" && $resolved_path === false) { |
| 1449 |
throw new InvalidArgumentException("Selected file-index root is a broken symlink: {$requested_path}"); |
| 1450 |
} |
| 1451 |
if ($resolved_path === false) { |
| 1452 |
throw new InvalidArgumentException( |
| 1453 |
"Selected file-index root does not exist or is not accessible: {$requested_path}" |
| 1454 |
); |
| 1455 |
} |
| 1456 |
if (empty($config["follow_symlinks"])) { |
| 1457 |
$parent_link = file_index_parent_symlink($requested_path); |
| 1458 |
if ($parent_link !== null) { |
| 1459 |
throw new InvalidArgumentException( |
| 1460 |
"Selected file-index root {$requested_path} is reached through parent symlink " . |
| 1461 |
"{$parent_link["path"]} targeting {$parent_link["target"]}; use --follow-symlinks." |
| 1462 |
); |
| 1463 |
} |
| 1464 |
} |
| 1465 |
$roots[] = [ |
| 1466 |
"requested_path" => $requested_path, |
| 1467 |
"resolved_path" => $resolved_path, |
| 1468 |
"type" => $type, |
| 1469 |
]; |
| 1470 |
} |
| 1471 |
|
| 1472 |
return $roots; |
| 1473 |
} |
| 1474 |
|
| 1475 |
/** |
| 1476 |
* Returns the file-index root for the file_index request's `list_dir` parameter. |
| 1477 |
* |
| 1478 |
* `list_dir` normally names a path from `directory[]`. When following symlinks, |
| 1479 |
* it may instead name a resolved directory found through a link below one of |
| 1480 |
* those selected paths. |
| 1481 |
* |
| 1482 |
* Example: `directory[]` contains /site. If indexing /site finds a link from |
| 1483 |
* /site/theme to /shared/theme, the client later requests |
| 1484 |
* `list_dir=/shared/theme`. This function returns a file-index root for |
| 1485 |
* /shared/theme even though it is not in `directory[]`. |
| 1486 |
* |
| 1487 |
* @param array[] $roots File-index roots returned by resolve_file_index_roots(). |
| 1488 |
* @param string $list_directory Value sent as `list_dir`. |
| 1489 |
* @param bool $follow_symlinks Whether `list_dir` may name a directory reached through a link. |
| 1490 |
* @return array { |
| 1491 |
* File-index root for `list_dir`. |
| 1492 |
* |
| 1493 |
* @type string $requested_path Requested normalized root path. |
| 1494 |
* @type string|null $resolved_path Resolved root path, when available. |
| 1495 |
* @type string $type directory, file, symlink, or missing. |
| 1496 |
* } |
| 1497 |
*/ |
| 1498 |
function resolve_file_index_start_root( |
| 1499 |
array $roots, |
| 1500 |
string $list_directory, |
| 1501 |
bool $follow_symlinks |
| 1502 |
): array { |
| 1503 |
$requested_path = normalize_path($list_directory); |
| 1504 |
foreach ($roots as $root) { |
| 1505 |
if ($root["requested_path"] === $requested_path) { |
| 1506 |
return $root; |
| 1507 |
} |
| 1508 |
} |
| 1509 |
|
| 1510 |
if (!$follow_symlinks) { |
| 1511 |
throw new InvalidArgumentException( |
| 1512 |
"list_dir must name a selected root unless follow_symlinks is enabled: {$requested_path}" |
| 1513 |
); |
| 1514 |
} |
| 1515 |
|
| 1516 |
$resolved_path = @realpath($requested_path); |
| 1517 |
if ($resolved_path === false || !is_dir($resolved_path)) { |
| 1518 |
throw new InvalidArgumentException( |
| 1519 |
"Followed symlink target directory does not exist or is not accessible: {$requested_path}" |
| 1520 |
); |
| 1521 |
} |
| 1522 |
|
| 1523 |
return [ |
| 1524 |
"requested_path" => $requested_path, |
| 1525 |
"resolved_path" => $resolved_path, |
| 1526 |
"type" => "directory", |
| 1527 |
]; |
| 1528 |
} |
| 1529 |
|
| 1530 |
/** Returns the first symlink in a requested root's parent path. */ |
| 1531 |
function file_index_parent_symlink(string $requested_path): ?array |
| 1532 |
{ |
| 1533 |
$current = "/"; |
| 1534 |
$parts = explode("/", trim(dirname($requested_path), "/")); |
| 1535 |
foreach ($parts as $part) { |
| 1536 |
if ($part === "") { |
| 1537 |
continue; |
| 1538 |
} |
| 1539 |
$current = wp_join_unix_paths($current, $part); |
| 1540 |
if (!@is_link($current)) { |
| 1541 |
continue; |
| 1542 |
} |
| 1543 |
$target = @readlink($current); |
| 1544 |
return ["path" => $current, "target" => $target === false ? "(unreadable)" : $target]; |
| 1545 |
} |
| 1546 |
return null; |
| 1547 |
} |
| 1548 |
|
| 1549 |
/** |
| 1550 |
* Returns lightweight preflight checks: filesystem accessibility, DB connectivity, |
| 1551 |
* and environment details useful for diagnostics. |
| 1552 |
*/ |
| 1553 |
function endpoint_preflight(array $config): array |
| 1554 |
{ |
| 1555 |
// -- Resolve filesystem roots -- |
| 1556 |
// Determine which directories to scan: either from the client-provided |
| 1557 |
// "directory" config, or by auto-detecting from cwd/DOCUMENT_ROOT/__DIR__. |
| 1558 |
$directories = []; |
| 1559 |
$dir_error = null; |
| 1560 |
$has_root_input = array_key_exists("directory", $config) && $config["directory"] !== null; |
| 1561 |
if ($has_root_input) { |
| 1562 |
try { |
| 1563 |
$directories = resolve_directories($config); |
| 1564 |
} catch (Exception $e) { |
| 1565 |
$dir_error = $e->getMessage(); |
| 1566 |
} |
| 1567 |
} |
| 1568 |
|
| 1569 |
$search_roots = []; |
| 1570 |
if (!empty($directories)) { |
| 1571 |
$search_roots = $directories; |
| 1572 |
} else { |
| 1573 |
$filtered = array_filter( |
| 1574 |
[ |
| 1575 |
getcwd() ?: null, |
| 1576 |
$_SERVER["DOCUMENT_ROOT"] ?? null, |
| 1577 |
isset($_SERVER["SCRIPT_FILENAME"]) |
| 1578 |
? dirname($_SERVER["SCRIPT_FILENAME"]) |
| 1579 |
: null, |
| 1580 |
__DIR__, |
| 1581 |
], |
| 1582 |
function ($value) { |
| 1583 |
return $value !== null && $value !== ""; |
| 1584 |
} |
| 1585 |
); |
| 1586 |
$search_roots = normalize_path_list($filtered); |
| 1587 |
} |
| 1588 |
|
| 1589 |
// -- Detect WordPress installations -- |
| 1590 |
// Walk parent directories to find wp-load.php / wp-config.php. |
| 1591 |
$wp_detect = detect_wp_roots($search_roots); |
| 1592 |
$detected_root_paths = []; |
| 1593 |
foreach ($wp_detect["roots"] as $root) { |
| 1594 |
if (!empty($root["path"])) { |
| 1595 |
$detected_root_paths[] = $root["path"]; |
| 1596 |
} |
| 1597 |
} |
| 1598 |
$detected_root_paths = normalize_path_list($detected_root_paths); |
| 1599 |
|
| 1600 |
$wp_load_path = null; |
| 1601 |
foreach ($wp_detect["roots"] as $root) { |
| 1602 |
if (!empty($root["wp_load_path"]) && is_readable($root["wp_load_path"])) { |
| 1603 |
$wp_load_path = $root["wp_load_path"]; |
| 1604 |
break; |
| 1605 |
} |
| 1606 |
} |
| 1607 |
$preflight_error = null; |
| 1608 |
if (!$has_root_input && $wp_load_path === null) { |
| 1609 |
$preflight_error = |
| 1610 |
"wp-load.php not found and no root directories were provided"; |
| 1611 |
} |
| 1612 |
|
| 1613 |
$scan_roots = !empty($directories) ? $directories : $detected_root_paths; |
| 1614 |
if (empty($scan_roots)) { |
| 1615 |
$scan_roots = $search_roots; |
| 1616 |
} |
| 1617 |
$scan_roots = normalize_path_list($scan_roots); |
| 1618 |
|
| 1619 |
$wp_scan_roots = normalize_path_list( |
| 1620 |
array_merge($scan_roots, $detected_root_paths) |
| 1621 |
); |
| 1622 |
|
| 1623 |
// -- Probe each directory -- |
| 1624 |
// Check accessibility, read .htaccess files, and collect disk space info. |
| 1625 |
$dir_checks = []; |
| 1626 |
$htaccess_files = []; |
| 1627 |
$wp_paths = []; |
| 1628 |
if (!empty($scan_roots)) { |
| 1629 |
foreach ($scan_roots as $dir) { |
| 1630 |
$exists = is_dir($dir); |
| 1631 |
$readable = $exists && is_readable($dir); |
| 1632 |
$openable = false; |
| 1633 |
$disk_free = null; |
| 1634 |
$disk_total = null; |
| 1635 |
if ($readable) { |
| 1636 |
$dh = @opendir($dir); |
| 1637 |
if ($dh !== false) { |
| 1638 |
$openable = true; |
| 1639 |
@readdir($dh); |
| 1640 |
closedir($dh); |
| 1641 |
} |
| 1642 |
} |
| 1643 |
if ($openable) { |
| 1644 |
$disk_free = function_exists("disk_free_space") ? @disk_free_space($dir) : false; |
| 1645 |
$disk_total = function_exists("disk_total_space") ? @disk_total_space($dir) : false; |
| 1646 |
} |
| 1647 |
$dir_checks[] = [ |
| 1648 |
"path" => $dir, |
| 1649 |
"exists" => $exists, |
| 1650 |
"readable" => $readable, |
| 1651 |
"openable" => $openable, |
| 1652 |
"disk_free_bytes" => $disk_free !== false ? $disk_free : null, |
| 1653 |
"disk_total_bytes" => $disk_total !== false ? $disk_total : null, |
| 1654 |
]; |
| 1655 |
|
| 1656 |
$htaccess_path = wp_join_unix_paths($dir, ".htaccess"); |
| 1657 |
if (file_exists($htaccess_path)) { |
| 1658 |
$htaccess_readable = is_readable($htaccess_path); |
| 1659 |
$htaccess_size = @filesize($htaccess_path); |
| 1660 |
$htaccess_mtime = @filemtime($htaccess_path); |
| 1661 |
$htaccess_content = null; |
| 1662 |
$htaccess_truncated = false; |
| 1663 |
if ($htaccess_readable) { |
| 1664 |
$limit = 8192; |
| 1665 |
$fh = @fopen($htaccess_path, "r"); |
| 1666 |
if ($fh) { |
| 1667 |
$data = @fread($fh, $limit + 1); |
| 1668 |
fclose($fh); |
| 1669 |
if ($data !== false) { |
| 1670 |
if (strlen($data) > $limit) { |
| 1671 |
$htaccess_truncated = true; |
| 1672 |
$data = substr($data, 0, $limit); |
| 1673 |
} |
| 1674 |
$htaccess_content = $data; |
| 1675 |
} |
| 1676 |
} |
| 1677 |
} |
| 1678 |
$htaccess_files[] = [ |
| 1679 |
"path" => $htaccess_path, |
| 1680 |
"readable" => $htaccess_readable, |
| 1681 |
"size_bytes" => $htaccess_size !== false ? $htaccess_size : null, |
| 1682 |
"mtime" => $htaccess_mtime !== false ? $htaccess_mtime : null, |
| 1683 |
"content" => $htaccess_content, |
| 1684 |
"truncated" => $htaccess_truncated, |
| 1685 |
]; |
| 1686 |
} |
| 1687 |
|
| 1688 |
$plugins_dir = wp_join_unix_paths($dir, "wp-content/plugins"); |
| 1689 |
$mu_plugins_dir = wp_join_unix_paths($dir, "wp-content/mu-plugins"); |
| 1690 |
$themes_dir = wp_join_unix_paths($dir, "wp-content/themes"); |
| 1691 |
$wp_paths[] = [ |
| 1692 |
"root" => $dir, |
| 1693 |
"plugins_dir" => $plugins_dir, |
| 1694 |
"mu_plugins_dir" => $mu_plugins_dir, |
| 1695 |
"themes_dir" => $themes_dir, |
| 1696 |
]; |
| 1697 |
} |
| 1698 |
} |
| 1699 |
|
| 1700 |
if (!empty($wp_scan_roots)) { |
| 1701 |
foreach ($wp_scan_roots as $dir) { |
| 1702 |
$plugins_dir = wp_join_unix_paths($dir, "wp-content/plugins"); |
| 1703 |
$mu_plugins_dir = wp_join_unix_paths($dir, "wp-content/mu-plugins"); |
| 1704 |
$themes_dir = wp_join_unix_paths($dir, "wp-content/themes"); |
| 1705 |
$wp_paths[] = [ |
| 1706 |
"root" => $dir, |
| 1707 |
"plugins_dir" => $plugins_dir, |
| 1708 |
"mu_plugins_dir" => $mu_plugins_dir, |
| 1709 |
"themes_dir" => $themes_dir, |
| 1710 |
]; |
| 1711 |
} |
| 1712 |
} |
| 1713 |
|
| 1714 |
$wp_paths = normalize_path_list( |
| 1715 |
array_map( |
| 1716 |
function ($entry) { |
| 1717 |
return $entry["root"] ?? null; |
| 1718 |
}, |
| 1719 |
$wp_paths |
| 1720 |
) |
| 1721 |
); |
| 1722 |
$wp_paths = array_map(function ($root) { |
| 1723 |
return [ |
| 1724 |
"root" => $root, |
| 1725 |
"plugins_dir" => wp_join_unix_paths($root, "wp-content/plugins"), |
| 1726 |
"mu_plugins_dir" => wp_join_unix_paths($root, "wp-content/mu-plugins"), |
| 1727 |
"themes_dir" => wp_join_unix_paths($root, "wp-content/themes"), |
| 1728 |
]; |
| 1729 |
}, $wp_paths); |
| 1730 |
|
| 1731 |
$filesystem_ok = true; |
| 1732 |
if ($dir_error !== null) { |
| 1733 |
$filesystem_ok = false; |
| 1734 |
} elseif (!empty($dir_checks)) { |
| 1735 |
foreach ($dir_checks as $check) { |
| 1736 |
if (empty($check["openable"])) { |
| 1737 |
$filesystem_ok = false; |
| 1738 |
break; |
| 1739 |
} |
| 1740 |
} |
| 1741 |
} elseif ($wp_load_path === null) { |
| 1742 |
$filesystem_ok = false; |
| 1743 |
} |
| 1744 |
|
| 1745 |
// -- PHP resource limits -- |
| 1746 |
// Gather memory, upload, and execution limits so the client can tune |
| 1747 |
// its request sizes accordingly. |
| 1748 |
$memory_limit_raw = ini_get("memory_limit"); |
| 1749 |
$memory_limit_bytes = null; |
| 1750 |
if ($memory_limit_raw !== false && $memory_limit_raw !== "") { |
| 1751 |
if ($memory_limit_raw === "-1") { |
| 1752 |
$memory_limit_bytes = PHP_INT_MAX; |
| 1753 |
} else { |
| 1754 |
$memory_limit_bytes = parse_size($memory_limit_raw); |
| 1755 |
} |
| 1756 |
} |
| 1757 |
$memory_used = memory_get_usage(true); |
| 1758 |
$memory_available = |
| 1759 |
$memory_limit_bytes !== null && $memory_limit_bytes !== PHP_INT_MAX |
| 1760 |
? max(0, $memory_limit_bytes - $memory_used) |
| 1761 |
: null; |
| 1762 |
$post_max_size_raw = ini_get("post_max_size"); |
| 1763 |
$upload_max_filesize_raw = ini_get("upload_max_filesize"); |
| 1764 |
$post_max_bytes = |
| 1765 |
$post_max_size_raw !== false && $post_max_size_raw !== "" |
| 1766 |
? parse_size($post_max_size_raw) |
| 1767 |
: null; |
| 1768 |
$upload_max_bytes = |
| 1769 |
$upload_max_filesize_raw !== false && $upload_max_filesize_raw !== "" |
| 1770 |
? parse_size($upload_max_filesize_raw) |
| 1771 |
: null; |
| 1772 |
$max_request_bytes = null; |
| 1773 |
if ($post_max_bytes !== null && $upload_max_bytes !== null) { |
| 1774 |
$max_request_bytes = min($post_max_bytes, $upload_max_bytes); |
| 1775 |
} elseif ($post_max_bytes !== null) { |
| 1776 |
$max_request_bytes = $post_max_bytes; |
| 1777 |
} elseif ($upload_max_bytes !== null) { |
| 1778 |
$max_request_bytes = $upload_max_bytes; |
| 1779 |
} |
| 1780 |
|
| 1781 |
// -- PHP extensions -- |
| 1782 |
// Report loaded extensions and image processing capabilities. |
| 1783 |
$extensions = get_loaded_extensions(); |
| 1784 |
sort($extensions, SORT_STRING); |
| 1785 |
$extension_versions = []; |
| 1786 |
foreach ([ |
| 1787 |
"curl", |
| 1788 |
"gd", |
| 1789 |
"imagick", |
| 1790 |
"pdo_mysql", |
| 1791 |
"mysqli", |
| 1792 |
"mbstring", |
| 1793 |
"zlib", |
| 1794 |
"openssl", |
| 1795 |
"fileinfo", |
| 1796 |
"exif", |
| 1797 |
] as $ext) { |
| 1798 |
if (extension_loaded($ext)) { |
| 1799 |
$ver = phpversion($ext); |
| 1800 |
$extension_versions[$ext] = $ver !== false ? $ver : true; |
| 1801 |
} |
| 1802 |
} |
| 1803 |
|
| 1804 |
$gd_info = function_exists("gd_info") ? gd_info() : null; |
| 1805 |
$gd_formats = null; |
| 1806 |
$gd_version = null; |
| 1807 |
if (is_array($gd_info)) { |
| 1808 |
$gd_version = $gd_info["GD Version"] ?? null; |
| 1809 |
$gd_formats = [ |
| 1810 |
"gif_create" => (bool) ($gd_info["GIF Create Support"] ?? false), |
| 1811 |
"gif_read" => (bool) ($gd_info["GIF Read Support"] ?? false), |
| 1812 |
"jpeg" => (bool) ($gd_info["JPEG Support"] ?? false), |
| 1813 |
"png" => (bool) ($gd_info["PNG Support"] ?? false), |
| 1814 |
"webp" => (bool) ($gd_info["WebP Support"] ?? false), |
| 1815 |
"avif" => (bool) ($gd_info["AVIF Support"] ?? false), |
| 1816 |
"bmp" => (bool) ($gd_info["BMP Support"] ?? false), |
| 1817 |
"wbmp" => (bool) ($gd_info["WBMP Support"] ?? false), |
| 1818 |
"xpm" => (bool) ($gd_info["XPM Support"] ?? false), |
| 1819 |
]; |
| 1820 |
} |
| 1821 |
$imagick_version = extension_loaded("imagick") |
| 1822 |
? (phpversion("imagick") ?: null) |
| 1823 |
: null; |
| 1824 |
|
| 1825 |
// -- Database connectivity -- |
| 1826 |
// Find wp-config.php credentials, connect to MySQL, and probe server |
| 1827 |
// variables (charset, collation, max_allowed_packet, sql_mode). |
| 1828 |
// If WordPress is loadable, also read options like active_plugins, |
| 1829 |
// theme, siteurl, multisite config, and WP constants. |
| 1830 |
$db = [ |
| 1831 |
"db_engine" => is_sqlite_site() ? "sqlite" : "mysql", |
| 1832 |
"credentials_found" => false, |
| 1833 |
"connected" => false, |
| 1834 |
"can_query" => false, |
| 1835 |
"version" => null, |
| 1836 |
"db_charset" => null, |
| 1837 |
"db_collation" => null, |
| 1838 |
"server_charset" => null, |
| 1839 |
"server_collation" => null, |
| 1840 |
"table_listable" => null, |
| 1841 |
"table_list_error" => null, |
| 1842 |
"wp" => [ |
| 1843 |
"wp_config_path" => null, |
| 1844 |
"wp_load_path" => null, |
| 1845 |
"wp_load_attempted" => false, |
| 1846 |
"wp_load_loaded" => false, |
| 1847 |
"wp_load_error" => null, |
| 1848 |
"table_prefix" => null, |
| 1849 |
"options_table" => null, |
| 1850 |
"active_plugins" => null, |
| 1851 |
"active_sitewide_plugins" => null, |
| 1852 |
"theme_template" => null, |
| 1853 |
"theme_stylesheet" => null, |
| 1854 |
"siteurl" => null, |
| 1855 |
"home" => null, |
| 1856 |
"paths_urls" => null, |
| 1857 |
"multisite" => null, |
| 1858 |
"constants" => null, |
| 1859 |
"constant_names" => null, |
| 1860 |
"wpdb_charset" => null, |
| 1861 |
"wpdb_collation" => null, |
| 1862 |
"error" => null, |
| 1863 |
], |
| 1864 |
"error" => null, |
| 1865 |
]; |
| 1866 |
|
| 1867 |
$credential_roots = []; |
| 1868 |
if (!empty($directories)) { |
| 1869 |
$credential_roots = $directories; |
| 1870 |
} elseif (!empty($detected_root_paths)) { |
| 1871 |
$credential_roots = $detected_root_paths; |
| 1872 |
} elseif (!empty($search_roots)) { |
| 1873 |
$credential_roots = $search_roots; |
| 1874 |
} |
| 1875 |
$credential_roots = normalize_path_list($credential_roots); |
| 1876 |
|
| 1877 |
$db["wp"]["wp_load_path"] = $wp_load_path; |
| 1878 |
$db["wp"]["wp_load_loaded"] = function_exists("get_option"); |
| 1879 |
|
| 1880 |
$creds = null; |
| 1881 |
try { |
| 1882 |
$creds = resolve_db_credentials(); |
| 1883 |
$db["wp"]["wp_config_path"] = $creds["wp_config_path"]; |
| 1884 |
$db["wp"]["table_prefix"] = $creds["table_prefix"]; |
| 1885 |
$db["db_engine"] = $creds["db_engine"] ?? $db["db_engine"]; |
| 1886 |
$db["credentials_found"] = true; |
| 1887 |
} catch (InvalidArgumentException $e) { |
| 1888 |
$db["error"] = $e->getMessage(); |
| 1889 |
} |
| 1890 |
|
| 1891 |
if ($creds !== null) { |
| 1892 |
$db_engine = $creds["db_engine"] ?? "mysql"; |
| 1893 |
$required_ext = $db_engine === "sqlite" ? "pdo_sqlite" : "pdo_mysql"; |
| 1894 |
$wpdb_available = $db_engine !== "sqlite" && isset($GLOBALS["wpdb"]) && is_object($GLOBALS["wpdb"]); |
| 1895 |
|
| 1896 |
if (!extension_loaded($required_ext) && !$wpdb_available) { |
| 1897 |
$db["error"] = "{$required_ext} extension not loaded"; |
| 1898 |
} else { |
| 1899 |
try { |
| 1900 |
$mysql = create_db_connection($creds); |
| 1901 |
$db["connected"] = true; |
| 1902 |
|
| 1903 |
$version = $mysql->query("SELECT VERSION()")->fetchColumn(); |
| 1904 |
$db["version"] = $version !== false ? (string) $version : null; |
| 1905 |
$db["can_query"] = true; |
| 1906 |
|
| 1907 |
$table_prefix = $db["wp"]["table_prefix"]; |
| 1908 |
if ($table_prefix === null || $table_prefix === "") { |
| 1909 |
try { |
| 1910 |
$stmt = $mysql->query( |
| 1911 |
"SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES " . |
| 1912 |
"WHERE TABLE_SCHEMA = DATABASE() " . |
| 1913 |
"AND TABLE_NAME LIKE '%\\_options' ESCAPE '\\\\' " . |
| 1914 |
"LIMIT 5" |
| 1915 |
); |
| 1916 |
if ($stmt !== false) { |
| 1917 |
$names = $stmt->fetchAll(PdoConstants::fetch_column()); |
| 1918 |
foreach ($names as $name) { |
| 1919 |
if (!is_string($name)) { |
| 1920 |
continue; |
| 1921 |
} |
| 1922 |
$suffix = "options"; |
| 1923 |
if ( |
| 1924 |
strlen($name) > strlen($suffix) && |
| 1925 |
substr($name, -strlen($suffix)) === $suffix |
| 1926 |
) { |
| 1927 |
$table_prefix = substr( |
| 1928 |
$name, |
| 1929 |
0, |
| 1930 |
-strlen($suffix) |
| 1931 |
); |
| 1932 |
break; |
| 1933 |
} |
| 1934 |
} |
| 1935 |
} |
| 1936 |
} catch (Exception $e) { |
| 1937 |
if ($db["wp"]["error"] === null) { |
| 1938 |
$db["wp"]["error"] = $e->getMessage(); |
| 1939 |
} |
| 1940 |
} |
| 1941 |
} |
| 1942 |
|
| 1943 |
if ($table_prefix !== null && $table_prefix !== "") { |
| 1944 |
$db["wp"]["table_prefix"] = $table_prefix; |
| 1945 |
$db["wp"]["options_table"] = $table_prefix . "options"; |
| 1946 |
} |
| 1947 |
|
| 1948 |
$wp_load_attempted = false; |
| 1949 |
$wp_load_error = null; |
| 1950 |
$wp_loaded = $db["wp"]["wp_load_loaded"]; |
| 1951 |
if (!$wp_loaded && $wp_load_path !== null) { |
| 1952 |
$wp_load_attempted = true; |
| 1953 |
$errors = []; |
| 1954 |
$handler = function ($errno, $errstr) use (&$errors) { |
| 1955 |
$errors[] = $errstr; |
| 1956 |
return true; |
| 1957 |
}; |
| 1958 |
set_error_handler($handler); |
| 1959 |
$include_result = @include_once $wp_load_path; |
| 1960 |
restore_error_handler(); |
| 1961 |
if ($include_result === false) { |
| 1962 |
$wp_load_error = !empty($errors) |
| 1963 |
? implode("; ", $errors) |
| 1964 |
: "Failed to include wp-load.php"; |
| 1965 |
} |
| 1966 |
if (function_exists("get_option")) { |
| 1967 |
$wp_loaded = true; |
| 1968 |
} elseif ($wp_load_error === null) { |
| 1969 |
$wp_load_error = "wp-load.php did not load WordPress functions"; |
| 1970 |
} |
| 1971 |
} |
| 1972 |
|
| 1973 |
$db["wp"]["wp_load_attempted"] = $wp_load_attempted; |
| 1974 |
$db["wp"]["wp_load_loaded"] = $wp_loaded; |
| 1975 |
if ($wp_load_error !== null) { |
| 1976 |
$db["wp"]["wp_load_error"] = $wp_load_error; |
| 1977 |
} |
| 1978 |
|
| 1979 |
if ($wp_loaded) { |
| 1980 |
try { |
| 1981 |
$wpdb_global = $GLOBALS["wpdb"] ?? null; |
| 1982 |
if (is_object($wpdb_global)) { |
| 1983 |
$wpdb_charset = (string) ($wpdb_global->charset ?? ""); |
| 1984 |
$db["wp"]["wpdb_charset"] = $wpdb_charset !== "" ? $wpdb_charset : null; |
| 1985 |
|
| 1986 |
$wpdb_collation = (string) ($wpdb_global->collate ?? ""); |
| 1987 |
$db["wp"]["wpdb_collation"] = $wpdb_collation !== "" ? $wpdb_collation : null; |
| 1988 |
} |
| 1989 |
|
| 1990 |
$db["wp"]["active_plugins"] = get_option("active_plugins"); |
| 1991 |
$db["wp"]["theme_stylesheet"] = get_option("stylesheet"); |
| 1992 |
$db["wp"]["theme_template"] = get_option("template"); |
| 1993 |
$db["wp"]["siteurl"] = get_option("siteurl"); |
| 1994 |
$db["wp"]["home"] = get_option("home"); |
| 1995 |
// Resolve wp-admin and wp-includes paths. |
| 1996 |
// These are always ABSPATH/wp-admin and ABSPATH/WPINC |
| 1997 |
// by WordPress convention, but on hosts like WP Cloud |
| 1998 |
// they may be symlinks (e.g. __wp__/wp-admin -> /wordpress/wp-admin). |
| 1999 |
// Use realpath() to resolve to the physical location so |
| 2000 |
// the importer knows where the files actually live. |
| 2001 |
$wp_admin_path = null; |
| 2002 |
if (defined("ABSPATH")) { |
| 2003 |
$wp_admin_candidate = wp_join_unix_paths(ABSPATH, "wp-admin"); |
| 2004 |
$wp_admin_real = realpath($wp_admin_candidate); |
| 2005 |
if ($wp_admin_real !== false && is_dir($wp_admin_real)) { |
| 2006 |
$wp_admin_path = $wp_admin_real; |
| 2007 |
} |
| 2008 |
} |
| 2009 |
|
| 2010 |
$wp_includes_path = null; |
| 2011 |
if (defined("ABSPATH")) { |
| 2012 |
$wpinc = defined("WPINC") ? WPINC : "wp-includes"; |
| 2013 |
$wp_includes_candidate = wp_join_unix_paths(ABSPATH, $wpinc); |
| 2014 |
$wp_includes_real = realpath($wp_includes_candidate); |
| 2015 |
if ($wp_includes_real !== false && is_dir($wp_includes_real)) { |
| 2016 |
$wp_includes_path = $wp_includes_real; |
| 2017 |
} |
| 2018 |
} |
| 2019 |
|
| 2020 |
// Use realpath() to resolve any symlinks in |
| 2021 |
// ABSPATH (e.g. /wordpress -> /srv/wpcloud/core/6.9.4 |
| 2022 |
// on WP Cloud). This matches the convention used for |
| 2023 |
// all other paths below and ensures the importer can |
| 2024 |
// find the directory at the resolved location where |
| 2025 |
// files are actually downloaded. |
| 2026 |
$abspath_raw = defined("ABSPATH") |
| 2027 |
? trim_right_slash(ABSPATH) |
| 2028 |
: null; |
| 2029 |
$abspath_resolved = null; |
| 2030 |
if ($abspath_raw !== null) { |
| 2031 |
$abspath_real = realpath($abspath_raw); |
| 2032 |
$abspath_resolved = $abspath_real !== false |
| 2033 |
? trim_right_slash($abspath_real) |
| 2034 |
: $abspath_raw; |
| 2035 |
} |
| 2036 |
|
| 2037 |
$paths_urls = [ |
| 2038 |
"abspath" => $abspath_resolved, |
| 2039 |
"wp_admin_path" => $wp_admin_path, |
| 2040 |
"wp_includes_path" => $wp_includes_path, |
| 2041 |
"content_dir" => defined("WP_CONTENT_DIR") |
| 2042 |
? realpath(WP_CONTENT_DIR) |
| 2043 |
: null, |
| 2044 |
"content_url" => function_exists("content_url") |
| 2045 |
? content_url() |
| 2046 |
: (defined("WP_CONTENT_URL") ? WP_CONTENT_URL : null), |
| 2047 |
"plugins_dir" => defined("WP_PLUGIN_DIR") |
| 2048 |
? realpath(WP_PLUGIN_DIR) |
| 2049 |
: null, |
| 2050 |
"plugins_url" => function_exists("plugins_url") |
| 2051 |
? plugins_url() |
| 2052 |
: (defined("WP_PLUGIN_URL") ? WP_PLUGIN_URL : null), |
| 2053 |
"mu_plugins_dir" => defined("WPMU_PLUGIN_DIR") |
| 2054 |
? realpath(WPMU_PLUGIN_DIR) |
| 2055 |
: null, |
| 2056 |
"mu_plugins_url" => function_exists("content_url") |
| 2057 |
? content_url("/mu-plugins") |
| 2058 |
: (defined("WPMU_PLUGIN_URL") ? WPMU_PLUGIN_URL : null), |
| 2059 |
"uploads" => [ |
| 2060 |
"basedir" => null, |
| 2061 |
"baseurl" => null, |
| 2062 |
"subdir" => null, |
| 2063 |
], |
| 2064 |
"site_url" => function_exists("site_url") |
| 2065 |
? site_url() |
| 2066 |
: null, |
| 2067 |
"home_url" => function_exists("home_url") |
| 2068 |
? home_url() |
| 2069 |
: null, |
| 2070 |
"network_site_url" => function_exists("network_site_url") |
| 2071 |
? network_site_url() |
| 2072 |
: null, |
| 2073 |
"network_home_url" => function_exists("network_home_url") |
| 2074 |
? network_home_url() |
| 2075 |
: null, |
| 2076 |
]; |
| 2077 |
|
| 2078 |
if (function_exists("wp_upload_dir")) { |
| 2079 |
$uploads = wp_upload_dir(null, false); |
| 2080 |
if (is_array($uploads)) { |
| 2081 |
$raw_basedir = $uploads["basedir"] ?? null; |
| 2082 |
$paths_urls["uploads"]["basedir"] = |
| 2083 |
is_string($raw_basedir) ? realpath($raw_basedir) : null; |
| 2084 |
$paths_urls["uploads"]["baseurl"] = |
| 2085 |
$uploads["baseurl"] ?? null; |
| 2086 |
$paths_urls["uploads"]["subdir"] = |
| 2087 |
$uploads["subdir"] ?? null; |
| 2088 |
} |
| 2089 |
} |
| 2090 |
$db["wp"]["paths_urls"] = $paths_urls; |
| 2091 |
|
| 2092 |
if ( |
| 2093 |
function_exists("is_multisite") && |
| 2094 |
is_multisite() && |
| 2095 |
function_exists("get_site_option") |
| 2096 |
) { |
| 2097 |
$db["wp"]["active_sitewide_plugins"] = get_site_option( |
| 2098 |
"active_sitewide_plugins" |
| 2099 |
); |
| 2100 |
} |
| 2101 |
|
| 2102 |
$multisite = [ |
| 2103 |
"enabled" => false, |
| 2104 |
"subdomain_install" => defined("SUBDOMAIN_INSTALL") |
| 2105 |
? (bool) SUBDOMAIN_INSTALL |
| 2106 |
: null, |
| 2107 |
"current_blog_id" => |
| 2108 |
function_exists("get_current_blog_id") |
| 2109 |
? get_current_blog_id() |
| 2110 |
: null, |
| 2111 |
"current_network_id" => |
| 2112 |
function_exists("get_current_network_id") |
| 2113 |
? get_current_network_id() |
| 2114 |
: null, |
| 2115 |
"domain_current_site" => defined("DOMAIN_CURRENT_SITE") |
| 2116 |
? DOMAIN_CURRENT_SITE |
| 2117 |
: null, |
| 2118 |
"path_current_site" => defined("PATH_CURRENT_SITE") |
| 2119 |
? PATH_CURRENT_SITE |
| 2120 |
: null, |
| 2121 |
"site_id_current_site" => |
| 2122 |
defined("SITE_ID_CURRENT_SITE") |
| 2123 |
? SITE_ID_CURRENT_SITE |
| 2124 |
: null, |
| 2125 |
"blog_id_current_site" => |
| 2126 |
defined("BLOG_ID_CURRENT_SITE") |
| 2127 |
? BLOG_ID_CURRENT_SITE |
| 2128 |
: null, |
| 2129 |
"network" => null, |
| 2130 |
"site" => null, |
| 2131 |
]; |
| 2132 |
|
| 2133 |
if (function_exists("is_multisite") && is_multisite()) { |
| 2134 |
$multisite["enabled"] = true; |
| 2135 |
$network_id = $multisite["current_network_id"]; |
| 2136 |
if ($network_id !== null && function_exists("get_network")) { |
| 2137 |
$network = get_network($network_id); |
| 2138 |
if (is_object($network)) { |
| 2139 |
$multisite["network"] = [ |
| 2140 |
"id" => $network->id ?? null, |
| 2141 |
"domain" => $network->domain ?? null, |
| 2142 |
"path" => $network->path ?? null, |
| 2143 |
"site_id" => $network->site_id ?? null, |
| 2144 |
"registered" => $network->registered ?? null, |
| 2145 |
"last_updated" => $network->last_updated ?? null, |
| 2146 |
]; |
| 2147 |
} |
| 2148 |
} |
| 2149 |
|
| 2150 |
$blog_id = $multisite["current_blog_id"]; |
| 2151 |
if ($blog_id !== null && function_exists("get_site")) { |
| 2152 |
$site = get_site($blog_id); |
| 2153 |
if (is_object($site)) { |
| 2154 |
$multisite["site"] = [ |
| 2155 |
"blog_id" => $site->blog_id ?? null, |
| 2156 |
"domain" => $site->domain ?? null, |
| 2157 |
"path" => $site->path ?? null, |
| 2158 |
"site_id" => $site->site_id ?? null, |
| 2159 |
"registered" => $site->registered ?? null, |
| 2160 |
"last_updated" => $site->last_updated ?? null, |
| 2161 |
"public" => $site->public ?? null, |
| 2162 |
"archived" => $site->archived ?? null, |
| 2163 |
"mature" => $site->mature ?? null, |
| 2164 |
"spam" => $site->spam ?? null, |
| 2165 |
"deleted" => $site->deleted ?? null, |
| 2166 |
"lang_id" => $site->lang_id ?? null, |
| 2167 |
]; |
| 2168 |
} |
| 2169 |
} |
| 2170 |
} |
| 2171 |
$db["wp"]["multisite"] = $multisite; |
| 2172 |
|
| 2173 |
// Capture all WP_* constants plus a few other |
| 2174 |
// WordPress-specific ones that don't follow the prefix. |
| 2175 |
// We use the "user" category from get_defined_constants(true) |
| 2176 |
// which only includes constants set via define(), excluding |
| 2177 |
// the thousands of constants from PHP extensions. |
| 2178 |
$user_constants = get_defined_constants(true)["user"] ?? []; |
| 2179 |
// Include non-WP_* constants that are still |
| 2180 |
// important for understanding a WordPress site. |
| 2181 |
$extra_constants_names = [ |
| 2182 |
"WPMU_PLUGIN_DIR", |
| 2183 |
"WPMU_PLUGIN_URL", |
| 2184 |
"UPLOADS", |
| 2185 |
"ABSPATH", |
| 2186 |
"DOMAIN_CURRENT_SITE", |
| 2187 |
"PATH_CURRENT_SITE", |
| 2188 |
"SITE_ID_CURRENT_SITE", |
| 2189 |
"BLOG_ID_CURRENT_SITE", |
| 2190 |
"SUBDOMAIN_INSTALL", |
| 2191 |
"TEMPLATEPATH", |
| 2192 |
"STYLESHEETPATH", |
| 2193 |
"FORCE_SSL_LOGIN", |
| 2194 |
"FORCE_SSL_ADMIN", |
| 2195 |
"SAVEQUERIES", |
| 2196 |
]; |
| 2197 |
$db["wp"]["constant_values"] = []; |
| 2198 |
// Names of all runtime-defined constants (without values) |
| 2199 |
// so the importer can use their presence as a detection |
| 2200 |
// signal without leaking secret values. Only includes |
| 2201 |
// constants set via define(), not PHP extension constants. |
| 2202 |
$db["wp"]["constant_names"] = []; |
| 2203 |
foreach ($user_constants as $name => $value) { |
| 2204 |
if (strncmp($name, "WP_", 3) === 0 || in_array($name, $extra_constants_names)) { |
| 2205 |
$db["wp"]["constant_values"][$name] = $value; |
| 2206 |
} else { |
| 2207 |
$db["wp"]["constant_names"][] = $name; |
| 2208 |
} |
| 2209 |
} |
| 2210 |
|
| 2211 |
global $wp_version; |
| 2212 |
$db["wp"]["wp_version"] = isset($wp_version) && is_string($wp_version) |
| 2213 |
? $wp_version |
| 2214 |
: null; |
| 2215 |
} catch (Exception $e) { |
| 2216 |
if ($db["wp"]["error"] === null) { |
| 2217 |
$db["wp"]["error"] = $e->getMessage(); |
| 2218 |
} |
| 2219 |
} catch (Throwable $e) { |
| 2220 |
if ($db["wp"]["error"] === null) { |
| 2221 |
$db["wp"]["error"] = $e->getMessage(); |
| 2222 |
} |
| 2223 |
} |
| 2224 |
} else { |
| 2225 |
if ($db["wp"]["error"] === null) { |
| 2226 |
if ($wp_load_error !== null) { |
| 2227 |
$db["wp"]["error"] = $wp_load_error; |
| 2228 |
} elseif ($wp_load_path === null) { |
| 2229 |
$db["wp"]["error"] = "wp-load.php not found"; |
| 2230 |
} else { |
| 2231 |
$db["wp"]["error"] = "wp-load.php not loaded"; |
| 2232 |
} |
| 2233 |
} |
| 2234 |
} |
| 2235 |
|
| 2236 |
// MySQL server variables — these don't apply to SQLite, |
| 2237 |
// so wrap in a separate try/catch to avoid losing WP data |
| 2238 |
// gathered earlier if the query fails. |
| 2239 |
try { |
| 2240 |
$vars = $mysql |
| 2241 |
->query( |
| 2242 |
"SELECT @@character_set_database AS db_charset, " . |
| 2243 |
"@@collation_database AS db_collation, " . |
| 2244 |
"@@character_set_server AS server_charset, " . |
| 2245 |
"@@collation_server AS server_collation, " . |
| 2246 |
"@@character_set_connection AS connection_charset, " . |
| 2247 |
"@@collation_connection AS connection_collation, " . |
| 2248 |
"@@max_allowed_packet AS max_allowed_packet, " . |
| 2249 |
"@@sql_mode AS sql_mode, " . |
| 2250 |
"@@lower_case_table_names AS lower_case_table_names" |
| 2251 |
) |
| 2252 |
->fetch(PdoConstants::fetch_assoc()); |
| 2253 |
if (is_array($vars)) { |
| 2254 |
$db["db_charset"] = $vars["db_charset"] ?? null; |
| 2255 |
$db["db_collation"] = $vars["db_collation"] ?? null; |
| 2256 |
$db["server_charset"] = $vars["server_charset"] ?? null; |
| 2257 |
$db["server_collation"] = $vars["server_collation"] ?? null; |
| 2258 |
$db["connection_charset"] = $vars["connection_charset"] ?? null; |
| 2259 |
$db["connection_collation"] = $vars["connection_collation"] ?? null; |
| 2260 |
$db["max_allowed_packet"] = isset($vars["max_allowed_packet"]) |
| 2261 |
? (int) $vars["max_allowed_packet"] |
| 2262 |
: null; |
| 2263 |
$db["sql_mode"] = $vars["sql_mode"] ?? null; |
| 2264 |
$db["lower_case_table_names"] = isset( |
| 2265 |
$vars["lower_case_table_names"] |
| 2266 |
) |
| 2267 |
? (int) $vars["lower_case_table_names"] |
| 2268 |
: null; |
| 2269 |
} |
| 2270 |
} catch (Exception $e) { |
| 2271 |
// Expected for SQLite — these MySQL system variables |
| 2272 |
// don't exist. The null defaults are correct. |
| 2273 |
} |
| 2274 |
|
| 2275 |
try { |
| 2276 |
$stmt = $mysql->query( |
| 2277 |
"SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES " . |
| 2278 |
"WHERE TABLE_SCHEMA = DATABASE() LIMIT 1" |
| 2279 |
); |
| 2280 |
if ($stmt !== false) { |
| 2281 |
$stmt->fetchColumn(); |
| 2282 |
$db["table_listable"] = true; |
| 2283 |
$db["table_list_error"] = null; |
| 2284 |
} else { |
| 2285 |
$db["table_listable"] = false; |
| 2286 |
$db["table_list_error"] = "SHOW TABLES failed"; |
| 2287 |
} |
| 2288 |
} catch (Exception $e) { |
| 2289 |
$db["table_listable"] = false; |
| 2290 |
$db["table_list_error"] = $e->getMessage(); |
| 2291 |
} |
| 2292 |
} catch (Exception $e) { |
| 2293 |
$db["error"] = $e->getMessage(); |
| 2294 |
} |
| 2295 |
} |
| 2296 |
} |
| 2297 |
|
| 2298 |
// -- WordPress content inventory -- |
| 2299 |
// If WordPress was loaded, use its constants for the real plugin/theme/ |
| 2300 |
// mu-plugin paths. Otherwise, fall back to conventional wp-content/ layout. |
| 2301 |
// Scan each directory to list installed plugins, mu-plugins, and themes. |
| 2302 |
$wp_runtime_paths = null; |
| 2303 |
if ($db["wp"]["wp_load_loaded"]) { |
| 2304 |
$runtime_root = defined("ABSPATH") ? trim_right_slash(ABSPATH) : null; |
| 2305 |
$content_dir = defined("WP_CONTENT_DIR") |
| 2306 |
? trim_right_slash(WP_CONTENT_DIR) |
| 2307 |
: null; |
| 2308 |
$plugins_dir = defined("WP_PLUGIN_DIR") |
| 2309 |
? trim_right_slash(WP_PLUGIN_DIR) |
| 2310 |
: null; |
| 2311 |
$mu_plugins_dir = defined("WPMU_PLUGIN_DIR") |
| 2312 |
? trim_right_slash(WPMU_PLUGIN_DIR) |
| 2313 |
: null; |
| 2314 |
$themes_dir = null; |
| 2315 |
if (function_exists("get_theme_root")) { |
| 2316 |
$themes_dir = get_theme_root(); |
| 2317 |
if (is_string($themes_dir)) { |
| 2318 |
$themes_dir = trim_right_slash($themes_dir); |
| 2319 |
} else { |
| 2320 |
$themes_dir = null; |
| 2321 |
} |
| 2322 |
} |
| 2323 |
|
| 2324 |
if ($content_dir !== null) { |
| 2325 |
if ($plugins_dir === null) { |
| 2326 |
$plugins_dir = wp_join_unix_paths($content_dir, "plugins"); |
| 2327 |
} |
| 2328 |
if ($mu_plugins_dir === null) { |
| 2329 |
$mu_plugins_dir = wp_join_unix_paths($content_dir, "mu-plugins"); |
| 2330 |
} |
| 2331 |
if ($themes_dir === null) { |
| 2332 |
$themes_dir = wp_join_unix_paths($content_dir, "themes"); |
| 2333 |
} |
| 2334 |
} |
| 2335 |
|
| 2336 |
$wp_runtime_paths = [ |
| 2337 |
"root" => $runtime_root ?? $content_dir, |
| 2338 |
"content_dir" => $content_dir, |
| 2339 |
"plugins_dir" => $plugins_dir, |
| 2340 |
"mu_plugins_dir" => $mu_plugins_dir, |
| 2341 |
"themes_dir" => $themes_dir, |
| 2342 |
]; |
| 2343 |
} |
| 2344 |
|
| 2345 |
$wp_content = [ |
| 2346 |
"roots" => [], |
| 2347 |
]; |
| 2348 |
$wp_paths_to_scan = $wp_runtime_paths !== null ? [$wp_runtime_paths] : $wp_paths; |
| 2349 |
foreach ($wp_paths_to_scan as $paths) { |
| 2350 |
$root_entry = [ |
| 2351 |
"root" => $paths["root"], |
| 2352 |
"content_dir" => $paths["content_dir"] ?? null, |
| 2353 |
"plugins" => [], |
| 2354 |
"mu_plugins" => [], |
| 2355 |
"themes" => [], |
| 2356 |
]; |
| 2357 |
$plugins_dir = $paths["plugins_dir"] ?? null; |
| 2358 |
if ($plugins_dir !== null && is_dir($plugins_dir) && is_readable($plugins_dir)) { |
| 2359 |
$entries = @scandir($plugins_dir) ?: []; |
| 2360 |
foreach ($entries as $entry) { |
| 2361 |
if ($entry === "." || $entry === "..") { |
| 2362 |
continue; |
| 2363 |
} |
| 2364 |
$path = wp_join_unix_paths($plugins_dir, $entry); |
| 2365 |
$root_entry["plugins"][] = [ |
| 2366 |
"name" => $entry, |
| 2367 |
"type" => is_dir($path) ? "dir" : "file", |
| 2368 |
]; |
| 2369 |
} |
| 2370 |
usort( |
| 2371 |
$root_entry["plugins"], |
| 2372 |
function ($a, $b) { |
| 2373 |
return strcmp($a["name"], $b["name"]); |
| 2374 |
} |
| 2375 |
); |
| 2376 |
} |
| 2377 |
|
| 2378 |
$mu_plugins_dir = $paths["mu_plugins_dir"] ?? null; |
| 2379 |
if ($mu_plugins_dir !== null && is_dir($mu_plugins_dir) && is_readable($mu_plugins_dir)) { |
| 2380 |
$entries = @scandir($mu_plugins_dir) ?: []; |
| 2381 |
foreach ($entries as $entry) { |
| 2382 |
if ($entry === "." || $entry === "..") { |
| 2383 |
continue; |
| 2384 |
} |
| 2385 |
$path = wp_join_unix_paths($mu_plugins_dir, $entry); |
| 2386 |
$root_entry["mu_plugins"][] = [ |
| 2387 |
"name" => $entry, |
| 2388 |
"type" => is_dir($path) ? "dir" : "file", |
| 2389 |
]; |
| 2390 |
} |
| 2391 |
usort( |
| 2392 |
$root_entry["mu_plugins"], |
| 2393 |
function ($a, $b) { |
| 2394 |
return strcmp($a["name"], $b["name"]); |
| 2395 |
} |
| 2396 |
); |
| 2397 |
} |
| 2398 |
|
| 2399 |
$themes_dir = $paths["themes_dir"] ?? null; |
| 2400 |
if ($themes_dir !== null && is_dir($themes_dir) && is_readable($themes_dir)) { |
| 2401 |
$entries = @scandir($themes_dir) ?: []; |
| 2402 |
foreach ($entries as $entry) { |
| 2403 |
if ($entry === "." || $entry === "..") { |
| 2404 |
continue; |
| 2405 |
} |
| 2406 |
$path = wp_join_unix_paths($themes_dir, $entry); |
| 2407 |
if (is_dir($path)) { |
| 2408 |
$root_entry["themes"][] = $entry; |
| 2409 |
} |
| 2410 |
} |
| 2411 |
sort($root_entry["themes"]); |
| 2412 |
} |
| 2413 |
|
| 2414 |
$wp_content["roots"][] = $root_entry; |
| 2415 |
} |
| 2416 |
|
| 2417 |
$environment_variables = []; |
| 2418 |
if (PHP_VERSION_ID >= 70100) { |
| 2419 |
$all_environment_variables = getenv(); |
| 2420 |
if (is_array($all_environment_variables)) { |
| 2421 |
$environment_variables = $all_environment_variables; |
| 2422 |
} |
| 2423 |
} |
| 2424 |
$environment_variable_names = array_values(array_unique(array_merge( |
| 2425 |
array_keys($_ENV), |
| 2426 |
array_keys($environment_variables) |
| 2427 |
))); |
| 2428 |
|
| 2429 |
// -- Probe whether streaming responses can avoid double compression -- |
| 2430 |
$current_output_compression = ini_get("zlib.output_compression"); |
| 2431 |
$output_compression_is_on = ! in_array($current_output_compression, [false, "", "0"], true); |
| 2432 |
|
| 2433 |
$output_compression_can_be_disabled = true; |
| 2434 |
if ($output_compression_is_on) { |
| 2435 |
$output_compression_can_be_disabled = false; |
| 2436 |
|
| 2437 |
if (function_exists("ini_set")) { |
| 2438 |
@ini_set("zlib.output_compression", "0"); |
| 2439 |
|
| 2440 |
$probed = ini_get("zlib.output_compression"); |
| 2441 |
$output_compression_can_be_disabled = in_array($probed, [false, "", "0"], true); |
| 2442 |
|
| 2443 |
@ini_set("zlib.output_compression", $current_output_compression); |
| 2444 |
} |
| 2445 |
} |
| 2446 |
|
| 2447 |
// -- Assemble and return the preflight response -- |
| 2448 |
$ok = |
| 2449 |
$preflight_error === null && |
| 2450 |
$filesystem_ok && |
| 2451 |
(!empty($db["credentials_found"]) ? !empty($db["connected"]) : false); |
| 2452 |
$response = [ |
| 2453 |
"ok" => $ok, |
| 2454 |
"error" => $preflight_error, |
| 2455 |
"timestamp" => time(), |
| 2456 |
"protocol_version" => EXPORT_PROTOCOL_VERSION, |
| 2457 |
"wp_detect" => [ |
| 2458 |
"found" => !empty($wp_detect["roots"]), |
| 2459 |
"searched" => $wp_detect["searched"], |
| 2460 |
"roots" => $wp_detect["roots"], |
| 2461 |
"error" => |
| 2462 |
!empty($wp_detect["roots"]) |
| 2463 |
? null |
| 2464 |
: "wp-load.php or wp-config.php not found in parent directories", |
| 2465 |
], |
| 2466 |
"php" => [ |
| 2467 |
"version" => PHP_VERSION, |
| 2468 |
"sapi" => function_exists("php_sapi_name") ? php_sapi_name() : null, |
| 2469 |
"timezone" => date_default_timezone_get(), |
| 2470 |
"extensions" => $extensions, |
| 2471 |
"extension_versions" => $extension_versions, |
| 2472 |
], |
| 2473 |
"limits" => [ |
| 2474 |
"ini_max_execution_time" => (int) ini_get("max_execution_time"), |
| 2475 |
"ini_max_input_time" => (int) ini_get("max_input_time"), |
| 2476 |
"ini_default_socket_timeout" => (int) ini_get("default_socket_timeout"), |
| 2477 |
"max_input_vars" => (int) ini_get("max_input_vars"), |
| 2478 |
"max_file_uploads" => (int) ini_get("max_file_uploads"), |
| 2479 |
"post_max_size" => $post_max_size_raw !== false ? $post_max_size_raw : null, |
| 2480 |
"post_max_bytes" => $post_max_bytes, |
| 2481 |
"upload_max_filesize" => |
| 2482 |
$upload_max_filesize_raw !== false ? $upload_max_filesize_raw : null, |
| 2483 |
"upload_max_bytes" => $upload_max_bytes, |
| 2484 |
"max_request_bytes" => $max_request_bytes, |
| 2485 |
"output_buffering" => ini_get("output_buffering") ?: null, |
| 2486 |
"zlib_output_compression" => ini_get("zlib.output_compression") ?: null, |
| 2487 |
"zlib_output_compression_can_be_disabled" => $output_compression_can_be_disabled, |
| 2488 |
"disable_functions" => ini_get("disable_functions") ?: null, |
| 2489 |
"allow_url_fopen" => ini_get("allow_url_fopen") ?: null, |
| 2490 |
"open_basedir" => ini_get("open_basedir") ?: null, |
| 2491 |
], |
| 2492 |
"memory" => [ |
| 2493 |
"limit_raw" => $memory_limit_raw !== false ? $memory_limit_raw : null, |
| 2494 |
"limit_bytes" => $memory_limit_bytes, |
| 2495 |
"used_bytes" => $memory_used, |
| 2496 |
"available_bytes" => $memory_available, |
| 2497 |
], |
| 2498 |
"images" => [ |
| 2499 |
"gd" => [ |
| 2500 |
"available" => is_array($gd_info), |
| 2501 |
"version" => $gd_version, |
| 2502 |
"formats" => $gd_formats, |
| 2503 |
], |
| 2504 |
"imagick" => [ |
| 2505 |
"available" => $imagick_version !== null, |
| 2506 |
"version" => $imagick_version, |
| 2507 |
], |
| 2508 |
], |
| 2509 |
"runtime" => [ |
| 2510 |
"server_software" => $_SERVER["SERVER_SOFTWARE"] ?? null, |
| 2511 |
// Every effective INI directive as computed by the PHP runtime |
| 2512 |
// after merging php.ini, scanned .ini files, and htaccess |
| 2513 |
// overrides. This captures the full configuration without |
| 2514 |
// needing to read the .ini files themselves. |
| 2515 |
"ini_get_all" => ini_get_all(null, false), |
| 2516 |
"temp_dir" => function_exists("sys_get_temp_dir") ? sys_get_temp_dir() : null, |
| 2517 |
"document_root" => $_SERVER["DOCUMENT_ROOT"] ?? null, |
| 2518 |
"script_filename" => $_SERVER["SCRIPT_FILENAME"] ?? null, |
| 2519 |
"cwd" => getcwd() ?: null, |
| 2520 |
// Names of environment variables exposed without their values so |
| 2521 |
// the importer can use their presence as a webhost detection |
| 2522 |
// signal. PHP 5.6 cannot list getenv(), so it contributes only |
| 2523 |
// names present in $_ENV. |
| 2524 |
"env_names" => $environment_variable_names, |
| 2525 |
'$_SERVER_names' => array_keys($_SERVER), |
| 2526 |
], |
| 2527 |
"filesystem" => [ |
| 2528 |
"directories" => $dir_checks, |
| 2529 |
"error" => $dir_error, |
| 2530 |
"ok" => $filesystem_ok, |
| 2531 |
], |
| 2532 |
"htaccess" => [ |
| 2533 |
"files" => $htaccess_files, |
| 2534 |
], |
| 2535 |
"wp_content" => $wp_content, |
| 2536 |
"database" => $db, |
| 2537 |
]; |
| 2538 |
|
| 2539 |
header("Content-Type: application/json"); |
| 2540 |
$json = json_encode($response); |
| 2541 |
if ($json === false) { |
| 2542 |
http_response_code(500); |
| 2543 |
echo '{"error":"Failed to serialize preflight response: ' . json_last_error_msg() . '"}'; |
| 2544 |
} else { |
| 2545 |
echo $json; |
| 2546 |
} |
| 2547 |
|
| 2548 |
return [ |
| 2549 |
"status" => $response["ok"] ? "ok" : "error", |
| 2550 |
"stats" => $response, |
| 2551 |
]; |
| 2552 |
} |
| 2553 |
|
| 2554 |
/** |
| 2555 |
* Streams file chunks from a producer as multipart/mixed. |
| 2556 |
*/ |
| 2557 |
function stream_file_producer( |
| 2558 |
$producer, |
| 2559 |
ResourceBudget $budget, |
| 2560 |
array $config = [], |
| 2561 |
bool $gzip = false |
| 2562 |
): array { |
| 2563 |
prepare_streaming_response(); |
| 2564 |
|
| 2565 |
['gz' => $gz, 'boundary' => $boundary] = begin_multipart_stream(false, $gzip); |
| 2566 |
|
| 2567 |
// E2E test hook: after gzip stream initialization (file producer) |
| 2568 |
if (getenv('SITE_EXPORT_TEST_MODE')) { |
| 2569 |
_e2e_load_test_hooks_if_needed($config); |
| 2570 |
$hook_args = [$gz, $boundary]; |
| 2571 |
_e2e_call_hook('test_hook_after_gzip_init', $hook_args); |
| 2572 |
} |
| 2573 |
|
| 2574 |
$chunks_processed = 0; |
| 2575 |
$files_completed = 0; |
| 2576 |
$bytes_processed = 0; |
| 2577 |
$last_progress_output = microtime(true); |
| 2578 |
$metadata_sent = false; |
| 2579 |
$iterations = 0; |
| 2580 |
$aborted = false; |
| 2581 |
$abort_payload = null; |
| 2582 |
$last_cursor = ""; |
| 2583 |
|
| 2584 |
// -- Stream chunks from the producer -- |
| 2585 |
// The producer yields file data, directories, symlinks, index entries, |
| 2586 |
// and progress updates. Each chunk type is wrapped in a multipart part |
| 2587 |
// with metadata headers (path, cursor, size, ctime). The loop runs |
| 2588 |
// until the producer is exhausted or the resource budget runs out. |
| 2589 |
$stream_failure = null; |
| 2590 |
try { |
| 2591 |
$initial_progress = $producer->get_progress(); |
| 2592 |
$initial_progress_json = json_encode_or_throw($initial_progress); |
| 2593 |
$initial_cursor = $producer->get_reentrancy_cursor(); |
| 2594 |
$last_cursor = $initial_cursor; |
| 2595 |
$gz->write( |
| 2596 |
"--{$boundary}\r\n" . |
| 2597 |
"Content-Type: application/json\r\n" . |
| 2598 |
"Content-Length: " . strlen($initial_progress_json) . "\r\n" . |
| 2599 |
"X-Chunk-Type: progress\r\n" . |
| 2600 |
"X-Cursor: " . base64_encode($initial_cursor) . "\r\n" . |
| 2601 |
"\r\n" . |
| 2602 |
$initial_progress_json . "\r\n" |
| 2603 |
); |
| 2604 |
$gz->sync(); |
| 2605 |
while (true) { |
| 2606 |
if ( |
| 2607 |
!$budget->has_remaining() |
| 2608 |
) { |
| 2609 |
break; |
| 2610 |
} |
| 2611 |
|
| 2612 |
if (!$producer->next_chunk()) { |
| 2613 |
break; |
| 2614 |
} |
| 2615 |
|
| 2616 |
$iterations++; |
| 2617 |
$chunk = $producer->get_current_chunk(); |
| 2618 |
$progress = $producer->get_progress(); |
| 2619 |
|
| 2620 |
if (!$metadata_sent && $progress["phase"] === "streaming") { |
| 2621 |
$filesystem_root = $producer->get_filesystem_root(); |
| 2622 |
$metadata = [ |
| 2623 |
"filesystem_root" => base64_encode($filesystem_root ?? ""), |
| 2624 |
]; |
| 2625 |
$metadata_json = json_encode_or_throw($metadata); |
| 2626 |
|
| 2627 |
$gz->write( |
| 2628 |
"--{$boundary}\r\n" . |
| 2629 |
"Content-Type: application/json\r\n" . |
| 2630 |
"Content-Length: " . strlen($metadata_json) . "\r\n" . |
| 2631 |
"X-Chunk-Type: metadata\r\n" . |
| 2632 |
"X-Filesystem-Root: " . base64_encode($filesystem_root ?? "") . "\r\n" . |
| 2633 |
"\r\n" . |
| 2634 |
$metadata_json . "\r\n" |
| 2635 |
); |
| 2636 |
$gz->sync(); |
| 2637 |
|
| 2638 |
$metadata_sent = true; |
| 2639 |
} |
| 2640 |
|
| 2641 |
if ($chunk === null) { |
| 2642 |
$now = microtime(true); |
| 2643 |
if ($iterations === 1 || $now - $last_progress_output >= 3.0) { |
| 2644 |
$progress_json = json_encode_or_throw($progress); |
| 2645 |
$cursor = $producer->get_reentrancy_cursor(); |
| 2646 |
$last_cursor = $cursor; |
| 2647 |
|
| 2648 |
$gz->write( |
| 2649 |
"--{$boundary}\r\n" . |
| 2650 |
"Content-Type: application/json\r\n" . |
| 2651 |
"Content-Length: " . strlen($progress_json) . "\r\n" . |
| 2652 |
"X-Chunk-Type: progress\r\n" . |
| 2653 |
"X-Cursor: " . base64_encode($cursor) . "\r\n" . |
| 2654 |
"\r\n" . |
| 2655 |
$progress_json . "\r\n" |
| 2656 |
); |
| 2657 |
$gz->sync(); |
| 2658 |
|
| 2659 |
$last_progress_output = $now; |
| 2660 |
} |
| 2661 |
|
| 2662 |
continue; |
| 2663 |
} |
| 2664 |
|
| 2665 |
$chunk_type = $chunk["type"] ?? "file"; |
| 2666 |
$cursor = $producer->get_reentrancy_cursor(); |
| 2667 |
$last_cursor = $cursor; |
| 2668 |
|
| 2669 |
if ($chunk_type === "directory") { |
| 2670 |
$part = |
| 2671 |
"--{$boundary}\r\n" . |
| 2672 |
"Content-Type: application/octet-stream\r\n" . |
| 2673 |
"Content-Length: 0\r\n" . |
| 2674 |
"X-Chunk-Type: directory\r\n" . |
| 2675 |
"X-Cursor: " . base64_encode($cursor) . "\r\n" . |
| 2676 |
"X-Directory-Path: " . base64_encode($chunk["path"]) . "\r\n"; |
| 2677 |
if (isset($chunk["ctime"])) { |
| 2678 |
$part .= "X-Directory-Ctime: " . $chunk["ctime"] . "\r\n"; |
| 2679 |
} |
| 2680 |
$gz->write($part . "\r\n\r\n"); |
| 2681 |
$gz->sync(); |
| 2682 |
} elseif ($chunk_type === "symlink") { |
| 2683 |
$gz->write( |
| 2684 |
"--{$boundary}\r\n" . |
| 2685 |
"Content-Type: application/octet-stream\r\n" . |
| 2686 |
"Content-Length: 0\r\n" . |
| 2687 |
"X-Chunk-Type: symlink\r\n" . |
| 2688 |
"X-Cursor: " . base64_encode($cursor) . "\r\n" . |
| 2689 |
"X-Symlink-Path: " . base64_encode($chunk["path"]) . "\r\n" . |
| 2690 |
"X-Symlink-Target: " . base64_encode($chunk["target"]) . "\r\n" . |
| 2691 |
"X-Symlink-Ctime: " . $chunk["ctime"] . "\r\n" . |
| 2692 |
"\r\n\r\n" |
| 2693 |
); |
| 2694 |
$gz->sync(); |
| 2695 |
} elseif ($chunk_type === "index") { |
| 2696 |
$gz->write( |
| 2697 |
"--{$boundary}\r\n" . |
| 2698 |
"Content-Type: application/octet-stream\r\n" . |
| 2699 |
"Content-Length: 0\r\n" . |
| 2700 |
"X-Chunk-Type: index\r\n" . |
| 2701 |
"X-Cursor: " . base64_encode($cursor) . "\r\n" . |
| 2702 |
"X-Index-Path: " . base64_encode($chunk["path"]) . "\r\n" . |
| 2703 |
"X-File-Ctime: " . $chunk["ctime"] . "\r\n" . |
| 2704 |
"X-File-Size: " . $chunk["size"] . "\r\n" . |
| 2705 |
"\r\n\r\n" |
| 2706 |
); |
| 2707 |
$gz->sync(); |
| 2708 |
} elseif ($chunk_type === "missing") { |
| 2709 |
$gz->write( |
| 2710 |
"--{$boundary}\r\n" . |
| 2711 |
"Content-Type: application/octet-stream\r\n" . |
| 2712 |
"Content-Length: 0\r\n" . |
| 2713 |
"X-Chunk-Type: missing\r\n" . |
| 2714 |
"X-Cursor: " . base64_encode($cursor) . "\r\n" . |
| 2715 |
"X-File-Path: " . base64_encode($chunk["path"]) . "\r\n" . |
| 2716 |
"\r\n\r\n" |
| 2717 |
); |
| 2718 |
$gz->sync(); |
| 2719 |
} elseif ($chunk_type === "error") { |
| 2720 |
$payload = [ |
| 2721 |
"error_type" => $chunk["error_type"] ?? "unknown", |
| 2722 |
"path" => base64_encode($chunk["path"] ?? ""), |
| 2723 |
"message" => $chunk["message"] ?? "Error", |
| 2724 |
]; |
| 2725 |
if (isset($chunk["expected_ctime"])) { |
| 2726 |
$payload["expected_ctime"] = $chunk["expected_ctime"]; |
| 2727 |
} |
| 2728 |
if (isset($chunk["actual_ctime"])) { |
| 2729 |
$payload["actual_ctime"] = $chunk["actual_ctime"]; |
| 2730 |
} |
| 2731 |
$json = json_encode_or_throw($payload); |
| 2732 |
$gz->write( |
| 2733 |
"--{$boundary}\r\n" . |
| 2734 |
"Content-Type: application/json\r\n" . |
| 2735 |
"Content-Length: " . strlen($json) . "\r\n" . |
| 2736 |
"X-Chunk-Type: error\r\n" . |
| 2737 |
"X-Cursor: " . base64_encode($cursor) . "\r\n" . |
| 2738 |
"\r\n" . |
| 2739 |
$json . "\r\n" |
| 2740 |
); |
| 2741 |
$gz->sync(); |
| 2742 |
} else { |
| 2743 |
// E2E test hook: before file chunk is emitted |
| 2744 |
if (getenv('SITE_EXPORT_TEST_MODE')) { |
| 2745 |
$hook_data = $chunk["data"]; |
| 2746 |
$hook_args = [$chunk["path"], $chunk["offset"], &$hook_data]; |
| 2747 |
_e2e_call_hook('test_hook_before_file_chunk', $hook_args); |
| 2748 |
$chunk["data"] = $hook_data; |
| 2749 |
} |
| 2750 |
|
| 2751 |
$chunks_processed++; |
| 2752 |
$bytes_processed += strlen($chunk["data"]); |
| 2753 |
if ($chunk["is_first_chunk"]) { |
| 2754 |
$files_completed++; |
| 2755 |
} |
| 2756 |
|
| 2757 |
$data = $chunk["data"]; |
| 2758 |
|
| 2759 |
$headers = |
| 2760 |
"--{$boundary}\r\n" . |
| 2761 |
"Content-Type: application/octet-stream\r\n" . |
| 2762 |
"Content-Length: " . strlen($data) . "\r\n" . |
| 2763 |
"X-Chunk-Type: file\r\n" . |
| 2764 |
"X-Cursor: " . base64_encode($cursor) . "\r\n" . |
| 2765 |
"X-File-Path: " . base64_encode($chunk["path"]) . "\r\n" . |
| 2766 |
"X-File-Size: " . $chunk["size"] . "\r\n" . |
| 2767 |
"X-File-Ctime: " . $chunk["ctime"] . "\r\n" . |
| 2768 |
"X-Chunk-Offset: " . $chunk["offset"] . "\r\n" . |
| 2769 |
"X-Chunk-Size: " . strlen($data) . "\r\n" . |
| 2770 |
"X-First-Chunk: " . ($chunk["is_first_chunk"] ? "1" : "0") . "\r\n" . |
| 2771 |
"X-Last-Chunk: " . ($chunk["is_last_chunk"] ? "1" : "0") . "\r\n"; |
| 2772 |
if (!empty($chunk["file_changed"])) { |
| 2773 |
$headers .= "X-File-Changed: 1\r\n"; |
| 2774 |
if ($chunk["change_ctime"] !== null) { |
| 2775 |
$headers .= "X-File-Change-Ctime: " . $chunk["change_ctime"] . "\r\n"; |
| 2776 |
} |
| 2777 |
if ($chunk["change_size"] !== null) { |
| 2778 |
$headers .= "X-File-Change-Size: " . $chunk["change_size"] . "\r\n"; |
| 2779 |
} |
| 2780 |
} |
| 2781 |
$gz->write($headers . "\r\n"); |
| 2782 |
$gz->write($data); |
| 2783 |
$gz->write("\r\n"); |
| 2784 |
$gz->sync(); |
| 2785 |
} |
| 2786 |
} |
| 2787 |
} catch (Exception $e) { |
| 2788 |
$stream_failure = $e; |
| 2789 |
} catch (Throwable $e) { |
| 2790 |
$stream_failure = $e; |
| 2791 |
} |
| 2792 |
|
| 2793 |
if ($stream_failure !== null) { |
| 2794 |
$aborted = true; |
| 2795 |
$abort_payload = [ |
| 2796 |
"error_type" => "exception", |
| 2797 |
"path" => "", |
| 2798 |
"message" => $stream_failure->getMessage(), |
| 2799 |
]; |
| 2800 |
} |
| 2801 |
|
| 2802 |
// Best-effort error and completion chunks — the client already has the |
| 2803 |
// data chunks. If the stream is broken at this point, log and move on. |
| 2804 |
$completion_failure = null; |
| 2805 |
try { |
| 2806 |
// @TODO: If an exception is thrown right after the previous chunk header, |
| 2807 |
// it read the fixed Content-Length value and will consume this next |
| 2808 |
// chunk as data. We should try and backfill the output up to the |
| 2809 |
// previous content-length value if possible. |
| 2810 |
if ($abort_payload !== null) { |
| 2811 |
$json = json_encode_or_throw($abort_payload); |
| 2812 |
$gz->write( |
| 2813 |
"--{$boundary}\r\n" . |
| 2814 |
"Content-Type: application/json\r\n" . |
| 2815 |
"Content-Length: " . strlen($json) . "\r\n" . |
| 2816 |
"X-Chunk-Type: error\r\n" . |
| 2817 |
"X-Cursor: " . base64_encode($last_cursor) . "\r\n" . |
| 2818 |
"\r\n" . |
| 2819 |
$json . "\r\n" |
| 2820 |
); |
| 2821 |
$gz->sync(); |
| 2822 |
} |
| 2823 |
|
| 2824 |
$progress = $producer->get_progress(); |
| 2825 |
$is_complete = $progress["phase"] === "finished" && !$aborted; |
| 2826 |
$status = $is_complete ? "complete" : "partial"; |
| 2827 |
|
| 2828 |
// E2E test hook: before completion chunk (file producer) |
| 2829 |
if (getenv('SITE_EXPORT_TEST_MODE')) { |
| 2830 |
$hook_args = [$status, $gz, $boundary]; |
| 2831 |
_e2e_call_hook('test_hook_before_completion', $hook_args); |
| 2832 |
} |
| 2833 |
|
| 2834 |
error_log( |
| 2835 |
"Export completion: status={$status}, phase={$progress["phase"]}, " . |
| 2836 |
"chunks={$chunks_processed}, files={$files_completed}, bytes={$bytes_processed}" |
| 2837 |
); |
| 2838 |
|
| 2839 |
$gz->write( |
| 2840 |
"--{$boundary}\r\n" . |
| 2841 |
"Content-Type: application/octet-stream\r\n" . |
| 2842 |
"Content-Length: 0\r\n" . |
| 2843 |
"X-Chunk-Type: completion\r\n" . |
| 2844 |
"X-Status: {$status}\r\n" . |
| 2845 |
"X-Chunks-Processed: {$chunks_processed}\r\n" . |
| 2846 |
"X-Files-Completed: {$files_completed}\r\n" . |
| 2847 |
"X-Bytes-Processed: {$bytes_processed}\r\n" . |
| 2848 |
"X-Memory-Used: " . memory_get_peak_usage(true) . "\r\n" . |
| 2849 |
"X-Memory-Limit: " . $budget->max_memory . "\r\n" . |
| 2850 |
"X-Time-Elapsed: " . (microtime(true) - $budget->start_time) . "\r\n" . |
| 2851 |
"\r\n" . |
| 2852 |
"\r\n" . |
| 2853 |
"--{$boundary}--\r\n" |
| 2854 |
); |
| 2855 |
$gz->finish(); |
| 2856 |
} catch (\Exception $e) { |
| 2857 |
$completion_failure = $e; |
| 2858 |
} catch (\Throwable $e) { |
| 2859 |
$completion_failure = $e; |
| 2860 |
} |
| 2861 |
if ($completion_failure !== null) { |
| 2862 |
error_log("Export: failed to write completion chunk: " . $completion_failure->getMessage()); |
| 2863 |
} |
| 2864 |
|
| 2865 |
$status = $aborted ? "partial" : ($status ?? "partial"); |
| 2866 |
|
| 2867 |
return [ |
| 2868 |
"status" => $status, |
| 2869 |
"stats" => [ |
| 2870 |
"chunks_processed" => $chunks_processed, |
| 2871 |
"files_completed" => $files_completed, |
| 2872 |
"bytes_processed" => $bytes_processed, |
| 2873 |
"memory_used" => memory_get_peak_usage(true), |
| 2874 |
"time_elapsed" => microtime(true) - $budget->start_time, |
| 2875 |
], |
| 2876 |
]; |
| 2877 |
} |
| 2878 |
|
| 2879 |
/** |
| 2880 |
* Encodes batch items for JSON serialization, base64-encoding paths |
| 2881 |
* to handle non-UTF8 filesystem bytes. |
| 2882 |
*/ |
| 2883 |
function encode_index_batch(array $batch_items): array |
| 2884 |
{ |
| 2885 |
$encoded = []; |
| 2886 |
foreach ($batch_items as $item) { |
| 2887 |
$entry = [ |
| 2888 |
"path" => base64_encode($item["path"]), |
| 2889 |
"ctime" => $item["ctime"], |
| 2890 |
"size" => $item["size"], |
| 2891 |
"type" => $item["type"], |
| 2892 |
]; |
| 2893 |
if (isset($item["target"])) { |
| 2894 |
$entry["target"] = base64_encode($item["target"]); |
| 2895 |
} |
| 2896 |
if (!empty($item["intermediate"])) { |
| 2897 |
$entry["intermediate"] = true; |
| 2898 |
} |
| 2899 |
if (isset($item["empty"])) { |
| 2900 |
$entry["empty"] = $item["empty"]; |
| 2901 |
} |
| 2902 |
$encoded[] = $entry; |
| 2903 |
} |
| 2904 |
return $encoded; |
| 2905 |
} |
| 2906 |
|
| 2907 |
/** |
| 2908 |
* Streams a directory index as gzipped JSON batches of {path, ctime, size, |
| 2909 |
* type}, plus an `empty` boolean on every inspected directory. |
| 2910 |
* |
| 2911 |
* FileIndexProcessor owns the resumable filesystem traversal. This endpoint |
| 2912 |
* owns HTTP framing, batching, request budgets, and error chunks. |
| 2913 |
*/ |
| 2914 |
function endpoint_file_index( |
| 2915 |
array $config, |
| 2916 |
ResourceBudget $budget |
| 2917 |
): array { |
| 2918 |
// This endpoint may run repeatedly in the same PHP process (e.g. PHP built-in |
| 2919 |
// server, long-lived workers). Clear stale stat/realpath cache from previous |
| 2920 |
// requests so path type transitions (symlink/file/dir) are seen correctly. |
| 2921 |
clearstatcache(true); |
| 2922 |
|
| 2923 |
$file_index_roots = resolve_file_index_roots($config); |
| 2924 |
$batch_size = require_int_range( |
| 2925 |
"batch_size", |
| 2926 |
(int) ($config["batch_size"] ?? 5000), |
| 2927 |
100, |
| 2928 |
100000 |
| 2929 |
); |
| 2930 |
$follow_symlinks = !empty($config["follow_symlinks"]); |
| 2931 |
$include_caches = !empty($config["include_caches"]); |
| 2932 |
$storage_path = isset($config["storage_path"]) && is_string($config["storage_path"]) |
| 2933 |
? $config["storage_path"] |
| 2934 |
: ""; |
| 2935 |
|
| 2936 |
if (isset($config["cursor"])) { |
| 2937 |
$file_index = FileIndexProcessor::resume( |
| 2938 |
$file_index_roots, |
| 2939 |
$config["cursor"], |
| 2940 |
$follow_symlinks, |
| 2941 |
$include_caches, |
| 2942 |
$storage_path |
| 2943 |
); |
| 2944 |
} else { |
| 2945 |
$list_directory = $config["list_dir"] ?? null; |
| 2946 |
if (!is_string($list_directory) || $list_directory === "") { |
| 2947 |
throw new InvalidArgumentException("list_dir is required for file_index"); |
| 2948 |
} |
| 2949 |
$start_root = resolve_file_index_start_root( |
| 2950 |
$file_index_roots, |
| 2951 |
$list_directory, |
| 2952 |
$follow_symlinks |
| 2953 |
); |
| 2954 |
$file_index = FileIndexProcessor::start( |
| 2955 |
$file_index_roots, |
| 2956 |
$start_root, |
| 2957 |
$follow_symlinks, |
| 2958 |
$include_caches, |
| 2959 |
$storage_path |
| 2960 |
); |
| 2961 |
} |
| 2962 |
|
| 2963 |
if (getenv('SITE_EXPORT_TEST_MODE')) { |
| 2964 |
_e2e_load_test_hooks_if_needed($config); |
| 2965 |
} |
| 2966 |
|
| 2967 |
$list_directory = $file_index->get_index_directory(); |
| 2968 |
$filesystem_root = $file_index_roots[0]["resolved_path"] ?? "/"; |
| 2969 |
|
| 2970 |
prepare_streaming_response(); |
| 2971 |
['gz' => $gz, 'boundary' => $boundary] = begin_multipart_stream(); |
| 2972 |
|
| 2973 |
$batches_emitted = 0; |
| 2974 |
$total_entries = 0; |
| 2975 |
$batch_items = []; |
| 2976 |
$status = "partial"; |
| 2977 |
$aborted = false; |
| 2978 |
$abort_payload = null; |
| 2979 |
|
| 2980 |
$stream_failure = null; |
| 2981 |
try { |
| 2982 |
$metadata = [ |
| 2983 |
"filesystem_root" => base64_encode($filesystem_root), |
| 2984 |
"list_dir" => base64_encode($list_directory), |
| 2985 |
]; |
| 2986 |
$metadata_json = json_encode_or_throw($metadata); |
| 2987 |
$gz->write( |
| 2988 |
"--{$boundary}\r\n" . |
| 2989 |
"Content-Type: application/json\r\n" . |
| 2990 |
"Content-Length: " . strlen($metadata_json) . "\r\n" . |
| 2991 |
"X-Chunk-Type: metadata\r\n" . |
| 2992 |
"X-Filesystem-Root: " . base64_encode($filesystem_root) . "\r\n" . |
| 2993 |
"X-Index-Dir: " . base64_encode($list_directory) . "\r\n" . |
| 2994 |
"\r\n" . |
| 2995 |
$metadata_json . "\r\n" |
| 2996 |
); |
| 2997 |
$gz->sync(); |
| 2998 |
|
| 2999 |
$stop = false; |
| 3000 |
while (!$stop) { |
| 3001 |
if (!$file_index->next_index_step()) { |
| 3002 |
$status = "complete"; |
| 3003 |
break; |
| 3004 |
} |
| 3005 |
|
| 3006 |
switch ($file_index->get_step_status()) { |
| 3007 |
case FileIndexProcessor::STATUS_INDEXED: |
| 3008 |
foreach ($file_index->get_index_entries() as $index_entry) { |
| 3009 |
$batch_items[] = $index_entry; |
| 3010 |
} |
| 3011 |
if (count($batch_items) >= $batch_size) { |
| 3012 |
emit_file_index_batch( |
| 3013 |
$gz, |
| 3014 |
$boundary, |
| 3015 |
$batch_items, |
| 3016 |
$file_index |
| 3017 |
); |
| 3018 |
$batches_emitted++; |
| 3019 |
$total_entries += count($batch_items); |
| 3020 |
$batch_items = []; |
| 3021 |
} |
| 3022 |
if (!$budget->has_remaining()) { |
| 3023 |
$stop = true; |
| 3024 |
} |
| 3025 |
break; |
| 3026 |
|
| 3027 |
case FileIndexProcessor::STATUS_PATH_UNAVAILABLE: |
| 3028 |
case FileIndexProcessor::STATUS_DIRECTORY_COMPLETE: |
| 3029 |
if (!$budget->has_remaining()) { |
| 3030 |
$stop = true; |
| 3031 |
} |
| 3032 |
break; |
| 3033 |
|
| 3034 |
case FileIndexProcessor::STATUS_DIRECTORY_ERROR: |
| 3035 |
$directory_error = $file_index->get_directory_error(); |
| 3036 |
emit_file_index_error( |
| 3037 |
$gz, |
| 3038 |
$boundary, |
| 3039 |
$directory_error, |
| 3040 |
$file_index->get_cursor() |
| 3041 |
); |
| 3042 |
break; |
| 3043 |
|
| 3044 |
case FileIndexProcessor::STATUS_SKIPPED: |
| 3045 |
// Cache, development, and Reprint-storage paths never |
| 3046 |
// entered the previous endpoint's budget checks either. |
| 3047 |
break; |
| 3048 |
} |
| 3049 |
} |
| 3050 |
} catch (Exception $e) { |
| 3051 |
$stream_failure = $e; |
| 3052 |
} catch (Throwable $e) { |
| 3053 |
$stream_failure = $e; |
| 3054 |
} |
| 3055 |
|
| 3056 |
if ($stream_failure !== null) { |
| 3057 |
$aborted = true; |
| 3058 |
$current_directory = $file_index->get_current_directory(); |
| 3059 |
$abort_payload = [ |
| 3060 |
"error_type" => "exception", |
| 3061 |
"path" => base64_encode($current_directory ?? $list_directory), |
| 3062 |
"message" => $stream_failure->getMessage(), |
| 3063 |
]; |
| 3064 |
} |
| 3065 |
|
| 3066 |
if (!empty($batch_items)) { |
| 3067 |
emit_file_index_batch($gz, $boundary, $batch_items, $file_index); |
| 3068 |
$batches_emitted++; |
| 3069 |
$total_entries += count($batch_items); |
| 3070 |
} |
| 3071 |
|
| 3072 |
$completion_failure = null; |
| 3073 |
try { |
| 3074 |
if ($abort_payload !== null) { |
| 3075 |
emit_file_index_error( |
| 3076 |
$gz, |
| 3077 |
$boundary, |
| 3078 |
$abort_payload, |
| 3079 |
$file_index->get_cursor(), |
| 3080 |
true |
| 3081 |
); |
| 3082 |
$status = "partial"; |
| 3083 |
} |
| 3084 |
|
| 3085 |
$cursor_json = json_encode_or_throw( |
| 3086 |
$file_index->get_cursor(), |
| 3087 |
JSON_UNESCAPED_SLASHES |
| 3088 |
); |
| 3089 |
$cursor_base64 = base64_encode($cursor_json); |
| 3090 |
$gz->write( |
| 3091 |
"--{$boundary}\r\n" . |
| 3092 |
"Content-Type: application/octet-stream\r\n" . |
| 3093 |
"Content-Length: 0\r\n" . |
| 3094 |
"X-Chunk-Type: completion\r\n" . |
| 3095 |
"X-Status: " . ($aborted ? "partial" : $status) . "\r\n" . |
| 3096 |
"X-Cursor: {$cursor_base64}\r\n" . |
| 3097 |
"X-Index-Dir: " . base64_encode($list_directory) . "\r\n" . |
| 3098 |
"X-Batches-Emitted: {$batches_emitted}\r\n" . |
| 3099 |
"X-Total-Entries: {$total_entries}\r\n" . |
| 3100 |
"X-Memory-Used: " . memory_get_peak_usage(true) . "\r\n" . |
| 3101 |
"X-Memory-Limit: " . $budget->max_memory . "\r\n" . |
| 3102 |
"X-Time-Elapsed: " . (microtime(true) - $budget->start_time) . "\r\n" . |
| 3103 |
"\r\n" . |
| 3104 |
"\r\n" . |
| 3105 |
"--{$boundary}--\r\n" |
| 3106 |
); |
| 3107 |
$gz->finish(); |
| 3108 |
} catch (Exception $e) { |
| 3109 |
$completion_failure = $e; |
| 3110 |
} catch (Throwable $e) { |
| 3111 |
$completion_failure = $e; |
| 3112 |
} finally { |
| 3113 |
$file_index->close(); |
| 3114 |
} |
| 3115 |
if ($completion_failure !== null) { |
| 3116 |
error_log("Export: failed to write completion chunk: " . $completion_failure->getMessage()); |
| 3117 |
} |
| 3118 |
|
| 3119 |
return [ |
| 3120 |
"status" => $aborted ? "partial" : $status, |
| 3121 |
"stats" => [ |
| 3122 |
"batches_emitted" => $batches_emitted, |
| 3123 |
"total_entries" => $total_entries, |
| 3124 |
"memory_used" => memory_get_peak_usage(true), |
| 3125 |
"time_elapsed" => microtime(true) - $budget->start_time, |
| 3126 |
], |
| 3127 |
]; |
| 3128 |
} |
| 3129 |
|
| 3130 |
/** |
| 3131 |
* Writes one file-index batch with the processor's current cursor. |
| 3132 |
* |
| 3133 |
* @param object $gzip_stream Gzip stream returned by begin_multipart_stream(). |
| 3134 |
* @param string $boundary Multipart boundary. |
| 3135 |
* @param array[] $batch_items File-index entries in this batch. |
| 3136 |
* @param FileIndexProcessor $file_index Active file-index processor. |
| 3137 |
*/ |
| 3138 |
function emit_file_index_batch( |
| 3139 |
$gzip_stream, |
| 3140 |
string $boundary, |
| 3141 |
array &$batch_items, |
| 3142 |
FileIndexProcessor $file_index |
| 3143 |
): void { |
| 3144 |
if (getenv('SITE_EXPORT_TEST_MODE')) { |
| 3145 |
$directory_stack = []; |
| 3146 |
foreach ($file_index->get_cursor()["stack"] as $encoded_frame) { |
| 3147 |
$directory_stack[] = [ |
| 3148 |
"dir" => base64_decode($encoded_frame["dir"]), |
| 3149 |
"after" => $encoded_frame["after"] !== null |
| 3150 |
? base64_decode($encoded_frame["after"]) |
| 3151 |
: null, |
| 3152 |
]; |
| 3153 |
} |
| 3154 |
$hook_args = [&$batch_items, $directory_stack]; |
| 3155 |
_e2e_call_hook('test_hook_before_index_batch', $hook_args); |
| 3156 |
} |
| 3157 |
|
| 3158 |
$cursor_json = json_encode_or_throw( |
| 3159 |
$file_index->get_cursor(), |
| 3160 |
JSON_UNESCAPED_SLASHES |
| 3161 |
); |
| 3162 |
$cursor_base64 = base64_encode($cursor_json); |
| 3163 |
$json = json_encode_or_throw( |
| 3164 |
encode_index_batch($batch_items), |
| 3165 |
JSON_UNESCAPED_SLASHES |
| 3166 |
); |
| 3167 |
$gzip_stream->write( |
| 3168 |
"--{$boundary}\r\n" . |
| 3169 |
"Content-Type: application/json\r\n" . |
| 3170 |
"Content-Length: " . strlen($json) . "\r\n" . |
| 3171 |
"X-Chunk-Type: index_batch\r\n" . |
| 3172 |
"X-Cursor: {$cursor_base64}\r\n" . |
| 3173 |
"X-Batch-Size: " . count($batch_items) . "\r\n" . |
| 3174 |
"\r\n" |
| 3175 |
); |
| 3176 |
$gzip_stream->write($json); |
| 3177 |
$gzip_stream->write("\r\n"); |
| 3178 |
$gzip_stream->sync(); |
| 3179 |
} |
| 3180 |
|
| 3181 |
/** |
| 3182 |
* Writes one file-index error with the cursor after that failure. |
| 3183 |
* |
| 3184 |
* @param object $gzip_stream Gzip stream returned by begin_multipart_stream(). |
| 3185 |
* @param string $boundary Multipart boundary. |
| 3186 |
* @param array $error { |
| 3187 |
* File-index error. |
| 3188 |
* |
| 3189 |
* @type string $error_type Protocol error type. |
| 3190 |
* @type string $path Filesystem path. |
| 3191 |
* @type string $message Human-readable explanation. |
| 3192 |
* } |
| 3193 |
* @param array $cursor { |
| 3194 |
* File-index cursor after the failure. |
| 3195 |
* |
| 3196 |
* @type array[] $stack Active directories with base64-encoded path names. |
| 3197 |
* } |
| 3198 |
* @param bool $path_is_base64 Whether the error path is already base64 text. |
| 3199 |
*/ |
| 3200 |
function emit_file_index_error( |
| 3201 |
$gzip_stream, |
| 3202 |
string $boundary, |
| 3203 |
array $error, |
| 3204 |
array $cursor, |
| 3205 |
bool $path_is_base64 = false |
| 3206 |
): void { |
| 3207 |
if (!$path_is_base64) { |
| 3208 |
$error["path"] = base64_encode($error["path"]); |
| 3209 |
} |
| 3210 |
$json = json_encode_or_throw($error); |
| 3211 |
$cursor_json = json_encode_or_throw($cursor, JSON_UNESCAPED_SLASHES); |
| 3212 |
$cursor_base64 = base64_encode($cursor_json); |
| 3213 |
$gzip_stream->write( |
| 3214 |
"--{$boundary}\r\n" . |
| 3215 |
"Content-Type: application/json\r\n" . |
| 3216 |
"Content-Length: " . strlen($json) . "\r\n" . |
| 3217 |
"X-Chunk-Type: error\r\n" . |
| 3218 |
"X-Cursor: {$cursor_base64}\r\n" . |
| 3219 |
"\r\n" . |
| 3220 |
$json . "\r\n" |
| 3221 |
); |
| 3222 |
$gzip_stream->sync(); |
| 3223 |
} |
| 3224 |
|
| 3225 |
/** |
| 3226 |
* Streams files from client-provided base64 path records uploaded as JSON. |
| 3227 |
*/ |
| 3228 |
function endpoint_file_fetch( |
| 3229 |
array $config, |
| 3230 |
ResourceBudget $budget |
| 3231 |
): array { |
| 3232 |
// Same rationale as endpoint_file_index(): avoid stale path metadata across |
| 3233 |
// requests in long-lived PHP processes. |
| 3234 |
clearstatcache(true); |
| 3235 |
|
| 3236 |
$directories = resolve_directories($config); |
| 3237 |
|
| 3238 |
$list_path = $config["file_list_path"] ?? null; |
| 3239 |
if ($list_path === null && isset($_FILES["file_list"])) { |
| 3240 |
$tmp_name = $_FILES["file_list"]["tmp_name"] ?? ""; |
| 3241 |
if ($tmp_name === "" || !is_uploaded_file($tmp_name)) { |
| 3242 |
throw new InvalidArgumentException( |
| 3243 |
"file_list upload missing or invalid" |
| 3244 |
); |
| 3245 |
} |
| 3246 |
$list_path = $tmp_name; |
| 3247 |
} |
| 3248 |
|
| 3249 |
if ($list_path === null) { |
| 3250 |
throw new InvalidArgumentException( |
| 3251 |
"file_list is required for file_fetch endpoint" |
| 3252 |
); |
| 3253 |
} |
| 3254 |
|
| 3255 |
$raw = file_get_contents($list_path); |
| 3256 |
if ($raw === false) { |
| 3257 |
throw new InvalidArgumentException("Failed to read file_list"); |
| 3258 |
} |
| 3259 |
$decoded = json_decode($raw, true); |
| 3260 |
if (!is_array($decoded)) { |
| 3261 |
throw new InvalidArgumentException( |
| 3262 |
"file_list must be a JSON array of base64 path records" |
| 3263 |
); |
| 3264 |
} |
| 3265 |
$paths = []; |
| 3266 |
foreach ($decoded as $entry_index => $entry) { |
| 3267 |
$encoded_path = null; |
| 3268 |
if (is_array($entry)) { |
| 3269 |
$encoded_path = $entry["path"] ?? null; |
| 3270 |
} |
| 3271 |
$path = is_string($encoded_path) |
| 3272 |
? base64_decode($encoded_path, true) |
| 3273 |
: false; |
| 3274 |
// phpcs:disable WordPress.Security.EscapeOutput.ExceptionNotEscaped -- Protocol error, never HTML output. |
| 3275 |
if (!is_string($path) || $path === "") { |
| 3276 |
throw new InvalidArgumentException( |
| 3277 |
"file_list entry {$entry_index} must contain a nonempty base64 path" |
| 3278 |
); |
| 3279 |
} |
| 3280 |
// phpcs:enable WordPress.Security.EscapeOutput.ExceptionNotEscaped |
| 3281 |
$paths[] = $path; |
| 3282 |
} |
| 3283 |
|
| 3284 |
$chunk_size = $config["chunk_size"] ?? FileTreeProducer::DEFAULT_CHUNK_SIZE; |
| 3285 |
$chunk_size = require_int_range( |
| 3286 |
"chunk_size", |
| 3287 |
(int) $chunk_size, |
| 3288 |
16 * 1024, |
| 3289 |
32 * 1024 * 1024 |
| 3290 |
); |
| 3291 |
|
| 3292 |
$sync_options = [ |
| 3293 |
"chunk_size" => $chunk_size, |
| 3294 |
"paths" => $paths, |
| 3295 |
]; |
| 3296 |
if (isset($config["cursor"])) { |
| 3297 |
$sync_options["cursor"] = $config["cursor"]; |
| 3298 |
} |
| 3299 |
|
| 3300 |
$producer = new FileTreeProducer($directories, $sync_options); |
| 3301 |
return stream_file_producer( |
| 3302 |
$producer, |
| 3303 |
$budget, |
| 3304 |
$config, |
| 3305 |
file_fetch_paths_should_gzip($paths) |
| 3306 |
); |
| 3307 |
} |
| 3308 |
|
| 3309 |
/** |
| 3310 |
* Decides whether to gzip a file_fetch multipart response based on the path |
| 3311 |
* list it will carry. |
| 3312 |
* |
| 3313 |
* Encoding is set per response (Content-Encoding is a response-level header), |
| 3314 |
* so we have to commit before any byte is sent. The trade-off: |
| 3315 |
* - Text-y bodies (PHP/JS/CSS/JSON/SQL/HTML/etc.) compress 5–60×. Gzip is |
| 3316 |
* a clear win on wire size and total wall time. |
| 3317 |
* - Image/video/audio/font/archive bodies are already compressed; passing |
| 3318 |
* them through gzip costs ~4 ms per 200 KB and produces ~0% size |
| 3319 |
* reduction (deflate falls back to literal stored blocks for incompressible |
| 3320 |
* input). Negligible per individual file, but unbounded if the batch is |
| 3321 |
* all-binary multiplied by request volume. |
| 3322 |
* |
| 3323 |
* Rule: gzip the response if **any** file in the batch is compressible. |
| 3324 |
* |
| 3325 |
* The previous all-or-nothing rule ("gzip only if every file is compressible") |
| 3326 |
* was over-conservative — a single PNG in a 200-CSS batch flipped the whole |
| 3327 |
* response to identity, losing ~50 % of wire size that would have compressed. |
| 3328 |
* The wasted CPU on the small binary portion of mixed batches is bounded by |
| 3329 |
* request size (capped server-side), so this trade-off favors smaller wire |
| 3330 |
* bytes on the common WordPress mixed batch (theme dirs, wp-content/uploads |
| 3331 |
* mixed with plugin assets) without harming the all-binary uploads case |
| 3332 |
* (which has zero compressible files and stays identity). |
| 3333 |
*/ |
| 3334 |
function file_fetch_paths_should_gzip(array $paths): bool |
| 3335 |
{ |
| 3336 |
if ($paths === []) { |
| 3337 |
return false; |
| 3338 |
} |
| 3339 |
$any_compressible = false; |
| 3340 |
foreach ($paths as $path) { |
| 3341 |
if (!is_string($path)) { |
| 3342 |
// Defensive: an unexpected non-string entry is a bad input we |
| 3343 |
// shouldn't compress around. Treat as a hard reject. |
| 3344 |
return false; |
| 3345 |
} |
| 3346 |
// Once true, we can skip checking the subsequent files. |
| 3347 |
if ($any_compressible) { |
| 3348 |
continue; |
| 3349 |
} |
| 3350 |
$ext = path_extension_compressibility($path); |
| 3351 |
if ($ext === 'yes') { |
| 3352 |
$any_compressible = true; |
| 3353 |
continue; |
| 3354 |
} |
| 3355 |
if ($ext === 'unknown') { |
| 3356 |
// Extension didn't match a known-text or known-binary list. Peek |
| 3357 |
// at the first 64 bytes and let the bytes decide. Cheap (one |
| 3358 |
// open/read/close per file) and means we don't have to grow the |
| 3359 |
// whitelist every time a plugin invents a new template suffix. |
| 3360 |
if (path_head_looks_like_text($path)) { |
| 3361 |
$any_compressible = true; |
| 3362 |
} |
| 3363 |
continue; |
| 3364 |
} |
| 3365 |
// 'no' — known binary. Skip; doesn't disqualify the batch. |
| 3366 |
} |
| 3367 |
return $any_compressible; |
| 3368 |
} |
| 3369 |
|
| 3370 |
/** |
| 3371 |
* Three-state classifier for a path's extension. |
| 3372 |
* |
| 3373 |
* - 'yes' known text-y extension (or dotfile / extensionless name). |
| 3374 |
* - 'no' known binary/already-compressed extension. |
| 3375 |
* - 'unknown' neither list matches; caller may probe the file bytes. |
| 3376 |
*/ |
| 3377 |
function path_extension_compressibility(string $path): string |
| 3378 |
{ |
| 3379 |
$basename = basename($path); |
| 3380 |
if ($basename === '') { |
| 3381 |
return 'no'; |
| 3382 |
} |
| 3383 |
// Dotfiles like .htaccess / .env / .gitignore have no "real" extension — |
| 3384 |
// pathinfo() reports the part after the leading dot as the extension, |
| 3385 |
// but they're text by convention. Treat the whole class as compressible. |
| 3386 |
if ($basename[0] === '.' && strpos($basename, '.', 1) === false) { |
| 3387 |
return 'yes'; |
| 3388 |
} |
| 3389 |
$ext = strtolower((string) pathinfo($basename, PATHINFO_EXTENSION)); |
| 3390 |
// Files with truly no extension (LICENSE, README, Makefile) — treat as text. |
| 3391 |
if ($ext === '') { |
| 3392 |
return 'yes'; |
| 3393 |
} |
| 3394 |
static $compressible = [ |
| 3395 |
// Source / markup |
| 3396 |
'php', 'phtml', 'js', 'jsx', 'ts', 'tsx', 'mjs', 'cjs', |
| 3397 |
'css', 'scss', 'sass', 'less', |
| 3398 |
'html', 'htm', 'xml', 'xsl', 'xslt', 'svg', |
| 3399 |
'vue', 'astro', 'twig', 'mustache', 'hbs', 'liquid', |
| 3400 |
// Data / config |
| 3401 |
'json', 'jsonl', 'yaml', 'yml', 'toml', 'csv', 'tsv', |
| 3402 |
'sql', 'ini', 'conf', 'cfg', 'env', 'properties', |
| 3403 |
// Docs / plain text |
| 3404 |
'md', 'markdown', 'txt', 'log', 'rst', 'adoc', |
| 3405 |
// Translations / feeds / captions |
| 3406 |
'pot', 'po', 'rss', 'atom', 'srt', 'vtt', 'webvtt', |
| 3407 |
// Misc text-y |
| 3408 |
'sh', 'bash', 'patch', 'diff', |
| 3409 |
]; |
| 3410 |
if (in_array($ext, $compressible, true)) { |
| 3411 |
return 'yes'; |
| 3412 |
} |
| 3413 |
static $incompressible = [ |
| 3414 |
// Already-compressed / encrypted archives |
| 3415 |
'zip', 'gz', 'tgz', 'bz2', 'xz', '7z', 'rar', 'tar', |
| 3416 |
// Images |
| 3417 |
'jpg', 'jpeg', 'png', 'gif', 'webp', 'heic', 'heif', 'avif', |
| 3418 |
'tiff', 'tif', 'bmp', 'ico', |
| 3419 |
// Audio |
| 3420 |
'mp3', 'm4a', 'aac', 'ogg', 'opus', 'flac', 'wav', |
| 3421 |
// Video |
| 3422 |
'mp4', 'm4v', 'mov', 'webm', 'mkv', 'avi', |
| 3423 |
// Fonts (already deflate-compressed in woff/woff2) |
| 3424 |
'woff', 'woff2', 'ttf', 'otf', 'eot', |
| 3425 |
// Misc binary blobs |
| 3426 |
'pdf', 'psd', 'sketch', 'fig', 'iso', 'dmg', 'mo', 'phar', |
| 3427 |
]; |
| 3428 |
if (in_array($ext, $incompressible, true)) { |
| 3429 |
return 'no'; |
| 3430 |
} |
| 3431 |
return 'unknown'; |
| 3432 |
} |
| 3433 |
|
| 3434 |
/** |
| 3435 |
* Probes the first bytes of a file to decide if it looks like text. |
| 3436 |
* |
| 3437 |
* Used as a fallback when the extension didn't match either the text or the |
| 3438 |
* binary list. The cost is one open + read + close per file in the |
| 3439 |
* file_fetch batch, which is negligible relative to streaming the file |
| 3440 |
* itself; the upside is we don't need to grow the extension lists every |
| 3441 |
* time a plugin invents a new template suffix. |
| 3442 |
* |
| 3443 |
* The check is deliberately strict: any NUL or other ASCII control byte |
| 3444 |
* (outside tab/newline/CR/form-feed) means binary, and the head must also |
| 3445 |
* decode as valid UTF-8. UTF-8 happens to reject most random binary |
| 3446 |
* sequences naturally because high-bit bytes only validate in well-formed |
| 3447 |
* multi-byte runs — so PNG, JPEG, ZIP, etc. fail this within a handful of |
| 3448 |
* bytes even when their headers look ASCII. |
| 3449 |
*/ |
| 3450 |
function path_head_looks_like_text(string $path): bool |
| 3451 |
{ |
| 3452 |
if (!is_file($path)) { |
| 3453 |
return false; |
| 3454 |
} |
| 3455 |
$fp = @fopen($path, 'rb'); |
| 3456 |
if ($fp === false) { |
| 3457 |
// Producer will surface a clearer error later; don't compress on |
| 3458 |
// unreadable paths. |
| 3459 |
return false; |
| 3460 |
} |
| 3461 |
$head = (string) fread($fp, 64); |
| 3462 |
fclose($fp); |
| 3463 |
if ($head === '') { |
| 3464 |
// Empty file: nothing to compress, default to identity. |
| 3465 |
return false; |
| 3466 |
} |
| 3467 |
// Any NUL byte → binary. Cheapest signal, catches PNG/ZIP/woff/etc. |
| 3468 |
if (strpos($head, "\x00") !== false) { |
| 3469 |
return false; |
| 3470 |
} |
| 3471 |
// Other ASCII control bytes (excluding TAB \x09, LF \x0A, FF \x0C, CR \x0D) |
| 3472 |
// shouldn't appear in source/data files. Also reject DEL \x7F. |
| 3473 |
if (preg_match('/[\x01-\x08\x0B\x0E-\x1F\x7F]/', $head)) { |
| 3474 |
return false; |
| 3475 |
} |
| 3476 |
// Must decode cleanly as UTF-8. mb_check_encoding handles the case where |
| 3477 |
// a multi-byte sequence is sliced by our 64-byte window: it returns false, |
| 3478 |
// which we treat as "not obviously text" — biased toward identity, which |
| 3479 |
// is the safe direction. |
| 3480 |
if (function_exists('mb_check_encoding') && !mb_check_encoding($head, 'UTF-8')) { |
| 3481 |
return false; |
| 3482 |
} |
| 3483 |
return true; |
| 3484 |
} |
| 3485 |
|
| 3486 |
/** |
| 3487 |
* Reports whether a path belongs to the established default file-index skip set. |
| 3488 |
* |
| 3489 |
* @param string $path Filesystem path to classify. |
| 3490 |
* @return bool Whether the path is omitted unless caches are included. |
| 3491 |
*/ |
| 3492 |
function path_is_default_skipped(string $path): bool |
| 3493 |
{ |
| 3494 |
return FileIndexProcessor::path_is_default_skipped($path); |
| 3495 |
} |
| 3496 |
|
| 3497 |
/** |
| 3498 |
* Maps importer-requested SQL row filters to producer row-exclusion rules. |
| 3499 |
* |
| 3500 |
* Rules are data, not exporter-known tokens. A client may provide: |
| 3501 |
* |
| 3502 |
* skip_rows[0][table_name_without_prefix]=postmeta |
| 3503 |
* skip_rows[0][column]=meta_key |
| 3504 |
* skip_rows[0][value_base64]=X2VkaXRfbG9jaw== |
| 3505 |
* |
| 3506 |
* `table_name_without_prefix` is appended to the server-side WordPress table prefix. The |
| 3507 |
* prefix must come from WordPress; if it cannot be resolved, clients must use |
| 3508 |
* explicit `table` instead. Values are base64-encoded so raw bytes never travel |
| 3509 |
* as SQL text. |
| 3510 |
* |
| 3511 |
* @return array[] { |
| 3512 |
* SQL row exclusion rules. |
| 3513 |
* |
| 3514 |
* @type string $table Table name. |
| 3515 |
* @type string $column Column name. |
| 3516 |
* @type string $value Column value to exclude. |
| 3517 |
* } |
| 3518 |
* @phpstan-return list<array{table: string, column: string, value: string}> |
| 3519 |
*/ |
| 3520 |
function sql_exclude_rows_from_config(array $config, ?string $table_prefix): array |
| 3521 |
{ |
| 3522 |
if (!isset($config["skip_rows"])) { |
| 3523 |
return []; |
| 3524 |
} |
| 3525 |
|
| 3526 |
$requested = $config["skip_rows"]; |
| 3527 |
if (is_string($requested)) { |
| 3528 |
$decoded = json_decode($requested, true); |
| 3529 |
if (!is_array($decoded)) { |
| 3530 |
throw new InvalidArgumentException("skip_rows string must be a JSON array"); |
| 3531 |
} |
| 3532 |
$requested = $decoded; |
| 3533 |
} |
| 3534 |
if (!is_array($requested)) { |
| 3535 |
throw new InvalidArgumentException("skip_rows must be an array"); |
| 3536 |
} |
| 3537 |
|
| 3538 |
$rules = []; |
| 3539 |
foreach ($requested as $index => $rule) { |
| 3540 |
if (!is_array($rule)) { |
| 3541 |
throw new InvalidArgumentException("skip_rows[{$index}] must be an object"); |
| 3542 |
} |
| 3543 |
|
| 3544 |
$has_table = isset($rule["table"]); |
| 3545 |
$has_table_name_without_prefix = isset($rule["table_name_without_prefix"]); |
| 3546 |
if ($has_table === $has_table_name_without_prefix) { |
| 3547 |
throw new InvalidArgumentException("skip_rows[{$index}] must include exactly one of table or table_name_without_prefix"); |
| 3548 |
} |
| 3549 |
if (!isset($rule["column"], $rule["value_base64"])) { |
| 3550 |
throw new InvalidArgumentException("skip_rows[{$index}] must include column and value_base64"); |
| 3551 |
} |
| 3552 |
if (!is_string($rule["column"]) || $rule["column"] === "") { |
| 3553 |
throw new InvalidArgumentException("skip_rows[{$index}].column must be a non-empty string"); |
| 3554 |
} |
| 3555 |
if (!is_string($rule["value_base64"])) { |
| 3556 |
throw new InvalidArgumentException("skip_rows[{$index}].value_base64 must be a string"); |
| 3557 |
} |
| 3558 |
|
| 3559 |
if ($has_table_name_without_prefix) { |
| 3560 |
if (!is_string($rule["table_name_without_prefix"]) || $rule["table_name_without_prefix"] === "") { |
| 3561 |
throw new InvalidArgumentException("skip_rows[{$index}].table_name_without_prefix must be a non-empty string"); |
| 3562 |
} |
| 3563 |
if ($table_prefix === null || $table_prefix === "") { |
| 3564 |
throw new InvalidArgumentException("skip_rows[{$index}].table_name_without_prefix requires a table_prefix"); |
| 3565 |
} |
| 3566 |
$table = $table_prefix . $rule["table_name_without_prefix"]; |
| 3567 |
} else { |
| 3568 |
if (!is_string($rule["table"]) || $rule["table"] === "") { |
| 3569 |
throw new InvalidArgumentException("skip_rows[{$index}].table must be a non-empty string"); |
| 3570 |
} |
| 3571 |
$table = $rule["table"]; |
| 3572 |
} |
| 3573 |
|
| 3574 |
$value = base64_decode($rule["value_base64"], true); |
| 3575 |
if ($value === false) { |
| 3576 |
throw new InvalidArgumentException("skip_rows[{$index}].value_base64 must be valid base64"); |
| 3577 |
} |
| 3578 |
|
| 3579 |
$rules[] = [ |
| 3580 |
"table" => $table, |
| 3581 |
"column" => $rule["column"], |
| 3582 |
"value" => $value, |
| 3583 |
]; |
| 3584 |
} |
| 3585 |
|
| 3586 |
return $rules; |
| 3587 |
} |
| 3588 |
|
| 3589 |
/** |
| 3590 |
* Validates that an integer falls within the given range, or throws. |
| 3591 |
*/ |
| 3592 |
function require_int_range( |
| 3593 |
string $name, |
| 3594 |
int $value, |
| 3595 |
int $min, |
| 3596 |
int $max |
| 3597 |
): int { |
| 3598 |
if ($value < $min || $value > $max) { |
| 3599 |
throw new InvalidArgumentException( |
| 3600 |
"{$name} out of range. Expected {$min}-{$max}, got {$value}" |
| 3601 |
); |
| 3602 |
} |
| 3603 |
return $value; |
| 3604 |
} |
| 3605 |
|
| 3606 |
/** |
| 3607 |
* Validates that a float falls within the given range, or throws. |
| 3608 |
*/ |
| 3609 |
function require_float_range( |
| 3610 |
string $name, |
| 3611 |
float $value, |
| 3612 |
float $min, |
| 3613 |
float $max |
| 3614 |
): float { |
| 3615 |
if ($value < $min || $value > $max) { |
| 3616 |
throw new InvalidArgumentException( |
| 3617 |
"{$name} out of range. Expected {$min}-{$max}, got {$value}" |
| 3618 |
); |
| 3619 |
} |
| 3620 |
return $value; |
| 3621 |
} |
| 3622 |
|
| 3623 |
/** |
| 3624 |
* Builds the config array from HTTP GET/POST parameters and optional JSON body. |
| 3625 |
*/ |
| 3626 |
function parse_http_config(): array |
| 3627 |
{ |
| 3628 |
$body = file_get_contents('php://input'); |
| 3629 |
if ($body === false) { |
| 3630 |
$body = ''; |
| 3631 |
} |
| 3632 |
|
| 3633 |
$server = new Site_Export_HTTP_Server(); |
| 3634 |
return $server->parse_http_config($_GET, $_POST, $_SERVER, $body); |
| 3635 |
} |
| 3636 |
|
