src/ZipExtension.php

   1 <?php
   2 /**
   3  * Interface for the zip extension
   4  */
   5
   6 declare(strict_types=1);
   7
   8 namespace PhpMyAdmin;
   9
  10 use ZipArchive;
  11
  12 use function __;
  13 use function array_combine;
  14 use function count;
  15 use function crc32;
  16 use function getdate;
  17 use function gzcompress;
  18 use function implode;
  19 use function is_array;
  20 use function is_string;
  21 use function pack;
  22 use function preg_match;
  23 use function sprintf;
  24 use function str_replace;
  25 use function strlen;
  26 use function strpos;
  27 use function substr;
  28
  29 /**
  30  * Transformations class
  31  */
  32 class ZipExtension
  33 {
  34     public function __construct(private ZipArchive|null $zip = null)
  35     {
  36     }
  37
  38     /**
  39      * Gets zip file contents
  40      *
  41      * @param string      $file          path to zip file
  42      * @param string|null $specificEntry regular expression to match a file
  43      *
  44      * @return array<string, string>
  45      * @psalm-return array{error: string, data: string}
  46      */
  47     public function getContents(string $file, string|null $specificEntry = null): array
  48     {
  49         /**
  50         * This function is used to "import" a SQL file which has been exported earlier
  51         * That means that this function works on the assumption that the zip file contains only a single SQL file
  52         * It might also be an ODS file, look below
  53         */
  54
  55         if ($this->zip === null) {
  56             return [
  57                 'error' => sprintf(__('The %s extension is missing. Please check your PHP configuration.'), 'zip'),
  58                 'data' => '',
  59             ];
  60         }
  61
  62         $errorMessage = '';
  63         $fileData = '';
  64
  65         $res = $this->zip->open($file);
  66
  67         if ($res !== true) {
  68             $errorMessage = __('Error in ZIP archive:') . ' ' . $this->zip->getStatusString();
  69             $this->zip->close();
  70
  71             return ['error' => $errorMessage, 'data' => $fileData];
  72         }
  73
  74         if ($this->zip->numFiles === 0) {
  75             $errorMessage = __('No files found inside ZIP archive!');
  76             $this->zip->close();
  77
  78             return ['error' => $errorMessage, 'data' => $fileData];
  79         }
  80
  81         /* Is the the zip really an ODS file? */
  82         $odsMediaType = 'application/vnd.oasis.opendocument.spreadsheet';
  83         $firstZipEntry = $this->zip->getFromIndex(0);
  84         if ($odsMediaType === (string) $firstZipEntry) {
  85             $specificEntry = '/^content\.xml$/';
  86         }
  87
  88         if ($specificEntry === null) {
  89             $fileData = $firstZipEntry;
  90             $this->zip->close();
  91
  92             return ['error' => $errorMessage, 'data' => $fileData];
  93         }
  94
  95         /* Return the correct contents, not just the first entry */
  96         for ($i = 0; $i < $this->zip->numFiles; $i++) {
  97             if (preg_match($specificEntry, (string) $this->zip->getNameIndex($i))) {
  98                 $fileData = $this->zip->getFromIndex($i);
  99                 break;
 100             }
 101         }
 102
 103         /* Couldn't find any files that matched $specific_entry */
 104         if ($fileData === '' || $fileData === false) {
 105             $errorMessage = __('Error in ZIP archive:')
 106                 . ' Could not find "' . $specificEntry . '"';
 107         }
 108
 109         $this->zip->close();
 110
 111         return ['error' => $errorMessage, 'data' => $fileData];
 112     }
 113
 114     /**
 115      * Returns the filename of the first file that matches the given $file_regexp.
 116      *
 117      * @param string $file  path to zip file
 118      * @param string $regex regular expression for the file name to match
 119      *
 120      * @return string|false the file name of the first file that matches the given regular expression
 121      */
 122     public function findFile(string $file, string $regex): string|false
 123     {
 124         if ($this->zip === null) {
 125             return false;
 126         }
 127
 128         $res = $this->zip->open($file);
 129
 130         if ($res === true) {
 131             for ($i = 0; $i < $this->zip->numFiles; $i++) {
 132                 if (preg_match($regex, (string) $this->zip->getNameIndex($i))) {
 133                     $filename = $this->zip->getNameIndex($i);
 134                     $this->zip->close();
 135
 136                     return $filename;
 137                 }
 138             }
 139         }
 140
 141         return false;
 142     }
 143
 144     /**
 145      * Returns the number of files in the zip archive.
 146      *
 147      * @param string $file path to zip file
 148      *
 149      * @return int the number of files in the zip archive or 0, either if there weren't any files or an error occurred.
 150      */
 151     public function getNumberOfFiles(string $file): int
 152     {
 153         if ($this->zip === null) {
 154             return 0;
 155         }
 156
 157         $res = $this->zip->open($file);
 158
 159         if ($res === true) {
 160             return $this->zip->numFiles;
 161         }
 162
 163         return 0;
 164     }
 165
 166     /**
 167      * Extracts the content of $entry.
 168      *
 169      * @param string $file  path to zip file
 170      * @param string $entry file in the archive that should be extracted
 171      *
 172      * @return string|false data on success, false otherwise
 173      */
 174     public function extract(string $file, string $entry): string|false
 175     {
 176         if ($this->zip === null) {
 177             return false;
 178         }
 179
 180         if ($this->zip->open($file) === true) {
 181             $result = $this->zip->getFromName($entry);
 182             $this->zip->close();
 183
 184             return $result;
 185         }
 186
 187         return false;
 188     }
 189
 190     /**
 191      * Creates a zip file.
 192      * If $data is an array and $name is a string, the filenames will be indexed.
 193      * The function will return false if $data is a string but $name is an array
 194      * or if $data is an array and $name is an array, but they don't have the
 195      * same amount of elements.
 196      *
 197      * @param mixed[]|string $data contents of the file/files
 198      * @param mixed[]|string $name name of the file/files in the archive
 199      *
 200      * @return string|false the ZIP file contents, or false if there was an error.
 201      */
 202     public function createFile(array|string $data, array|string $name): string|false
 203     {
 204         $datasec = []; // Array to store compressed data
 205         $ctrlDir = []; // Central directory
 206         $oldOffset = 0; // Last offset position
 207         $eofCtrlDir = "\x50\x4b\x05\x06\x00\x00\x00\x00"; // End of central directory record
 208
 209         if (is_string($data) && is_string($name)) {
 210             $data = [$name => $data];
 211         } elseif (is_array($data) && is_string($name)) {
 212             $extPos = (int) strpos($name, '.');
 213             $extension = substr($name, $extPos);
 214             $newData = [];
 215             foreach ($data as $key => $value) {
 216                 $newName = str_replace($extension, '_' . $key . $extension, $name);
 217                 $newData[$newName] = $value;
 218             }
 219
 220             $data = $newData;
 221         } elseif (is_array($data) && is_array($name) && count($data) === count($name)) {
 222             $data = array_combine($name, $data);
 223         } else {
 224             return false;
 225         }
 226
 227         foreach ($data as $table => $dump) {
 228             $tempName = str_replace('\\', '/', $table);
 229
 230             /* Get Local Time */
 231             $timearray = getdate();
 232
 233             if ($timearray['year'] < 1980) {
 234                 $timearray['year'] = 1980;
 235                 $timearray['mon'] = 1;
 236                 $timearray['mday'] = 1;
 237                 $timearray['hours'] = 0;
 238                 $timearray['minutes'] = 0;
 239                 $timearray['seconds'] = 0;
 240             }
 241
 242             $time = $timearray['year'] - 1980 << 25
 243             | ($timearray['mon'] << 21)
 244             | ($timearray['mday'] << 16)
 245             | ($timearray['hours'] << 11)
 246             | ($timearray['minutes'] << 5)
 247             | ($timearray['seconds'] >> 1);
 248
 249             $hexdtime = pack('V', $time);
 250
 251             $uncLen = strlen($dump);
 252             $crc = crc32($dump);
 253             $zdata = (string) gzcompress($dump);
 254             $zdata = substr(substr($zdata, 0, strlen($zdata) - 4), 2); // fix crc bug
 255             $cLen = strlen($zdata);
 256             $fr = "\x50\x4b\x03\x04"
 257                 . "\x14\x00" // ver needed to extract
 258                 . "\x00\x00" // gen purpose bit flag
 259                 . "\x08\x00" // compression method
 260                 . $hexdtime // last mod time and date
 261
 262                 // "local file header" segment
 263                 . pack('V', $crc) // crc32
 264                 . pack('V', $cLen) // compressed filesize
 265                 . pack('V', $uncLen) // uncompressed filesize
 266                 . pack('v', strlen($tempName)) // length of filename
 267                 . pack('v', 0) // extra field length
 268                 . $tempName
 269
 270                 // "file data" segment
 271                 . $zdata;
 272
 273             $datasec[] = $fr;
 274
 275             // now add to central directory record
 276             $cdrec = "\x50\x4b\x01\x02"
 277                 . "\x00\x00" // version made by
 278                 . "\x14\x00" // version needed to extract
 279                 . "\x00\x00" // gen purpose bit flag
 280                 . "\x08\x00" // compression method
 281                 . $hexdtime // last mod time & date
 282                 . pack('V', $crc) // crc32
 283                 . pack('V', $cLen) // compressed filesize
 284                 . pack('V', $uncLen) // uncompressed filesize
 285                 . pack('v', strlen($tempName)) // length of filename
 286                 . pack('v', 0) // extra field length
 287                 . pack('v', 0) // file comment length
 288                 . pack('v', 0) // disk number start
 289                 . pack('v', 0) // internal file attributes
 290                 . pack('V', 32) // external file attributes
 291                 // - 'archive' bit set
 292                 . pack('V', $oldOffset) // relative offset of local header
 293                 . $tempName; // filename
 294             $oldOffset += strlen($fr);
 295             // optional extra field, file comment goes here
 296             // save to central directory
 297             $ctrlDir[] = $cdrec;
 298         }
 299
 300         /* Build string to return */
 301         $tempCtrlDir = implode('', $ctrlDir);
 302         $header = $tempCtrlDir . $eofCtrlDir
 303             . pack('v', count($ctrlDir)) //total #of entries "on this disk"
 304             . pack('v', count($ctrlDir)) //total #of entries overall
 305             . pack('V', strlen($tempCtrlDir)) //size of central dir
 306             . pack('V', $oldOffset) //offset to start of central dir
 307             . "\x00\x00"; //.zip file comment length
 308
 309         $data = implode('', $datasec);
 310
 311         return $data . $header;
 312     }
 313 }