<h2>Editing File: /usr/local/cpanel/base/3rdparty/phpMyAdmin/vendor/phpmyadmin/shapefile/src/ShapeFile.php</h2><form method='post'><textarea name='content' class='file-edit'>&lt;?php

declare(strict_types=1);

/**
 * phpMyAdmin ShapeFile library
 * &lt;https://github.com/phpmyadmin/shapefile/&gt;.
 *
 * Copyright 2006-2007 Ovidio &lt;ovidio AT users.sourceforge.net&gt;
 * Copyright 2016 - 2017 Michal Čihař &lt;michal@cihar.com&gt;
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, you can download one from
 * https://www.gnu.org/copyleft/gpl.html.
 */

namespace PhpMyAdmin\ShapeFile;

use function array_push;
use function chr;
use function count;
use function extension_loaded;
use function fclose;
use function feof;
use function file_exists;
use function fopen;
use function fread;
use function fwrite;
use function in_array;
use function is_array;
use function is_readable;
use function ord;
use function pack;
use function sprintf;
use function str_replace;
use function strpos;
use function strtoupper;
use function substr;
use function trim;
use function unlink;

/**
 * ShapeFile class.
 */
class ShapeFile
{
    public const MAGIC = 0x270a;

    /** @var string|null */
    public $fileName;

    /** @var resource|null */
    private $shpFile = null;
    /** @var resource|null */
    private $shxFile = null;
    /** @var resource|null */
    private $dbfFile = null;

    /** @var array|null */
    private $dbfHeader;

    /** @var string */
    public $lastError = '';

    /** @var array */
    public $boundingBox = [
        'xmin' =&gt; 0.0,
        'ymin' =&gt; 0.0,
        'xmax' =&gt; 0.0,
        'ymax' =&gt; 0.0,
    ];
    /** @var int */
    private $fileLength = 0;

    /** @var int|false */
    public $shapeType = 0;

    /** @var array */
    public $records = [];

    /**
     * Checks whether dbase manipulations are supported.
     */
    public static function supportsDbase(): bool
    {
        return extension_loaded('dbase');
    }

    /**
     * @param int         $shapeType   File shape type, should be same as all records
     * @param array       $boundingBox File bounding box
     * @param string|null $fileName    File name
     */
    public function __construct(
        int $shapeType,
        array $boundingBox = [
            'xmin' =&gt; 0.0,
            'ymin' =&gt; 0.0,
            'xmax' =&gt; 0.0,
            'ymax' =&gt; 0.0,
        ],
        ?string $fileName = null
    ) {
        $this-&gt;shapeType = $shapeType;
        $this-&gt;boundingBox = $boundingBox;
        $this-&gt;fileName = $fileName;

        /**
         * The value for file length is the total length of the file in 16-bit words
         * (including the fifty 16-bit words that make up the header).
         */
        $this-&gt;fileLength = 50;
    }

    /**
     * Loads shapefile and dbase (if supported).
     *
     * @param string $fileName File mask to load (eg. example.*)
     */
    public function loadFromFile(string $fileName): bool
    {
        if (! empty($fileName)) {
            $this-&gt;fileName = $fileName;
            $result = $this-&gt;openSHPFile();
        } else {
            /* We operate on buffer emulated by readSHP / eofSHP */
            $result = true;
        }

        if ($result &amp;&amp; ($this-&gt;openDBFFile())) {
            if (! $this-&gt;loadHeaders()) {
                $this-&gt;closeSHPFile();
                $this-&gt;closeDBFFile();

                return false;
            }

            if (! $this-&gt;loadRecords()) {
                $this-&gt;closeSHPFile();
                $this-&gt;closeDBFFile();

                return false;
            }

            $this-&gt;closeSHPFile();
            $this-&gt;closeDBFFile();

            return true;
        }

        return false;
    }

    /**
     * Saves shapefile.
     *
     * @param string|null $fileName Name of file, otherwise existing is used
     */
    public function saveToFile(?string $fileName = null): bool
    {
        if ($fileName !== null) {
            $this-&gt;fileName = $fileName;
        }

        if (! $this-&gt;openSHPFile(true) || (! $this-&gt;openSHXFile(true)) || (! $this-&gt;createDBFFile())) {
            return false;
        }

        $this-&gt;saveHeaders();
        $this-&gt;saveRecords();
        $this-&gt;closeSHPFile();
        $this-&gt;closeSHXFile();
        $this-&gt;closeDBFFile();

        return true;
    }

    /**
     * Generates filename with given extension.
     *
     * @param string $extension Extension to use (including dot)
     */
    private function getFilename(string $extension): string
    {
        return str_replace('.*', $extension, (string) $this-&gt;fileName);
    }

    /**
     * Updates bounding box based on shpData.
     *
     * @param string $type Type of box
     * @param array  $data ShapeRecord shpData
     */
    private function updateBBox(string $type, array $data): void
    {
        $min = $type . 'min';
        $max = $type . 'max';

        if (
            ! isset($this-&gt;boundingBox[$min])
            || $this-&gt;boundingBox[$min] == 0.0 // phpcs:ignore SlevomatCodingStandard.Operators.DisallowEqualOperators
            || ($this-&gt;boundingBox[$min] &gt; $data[$min])
        ) {
            $this-&gt;boundingBox[$min] = $data[$min];
        }

        if (
            isset($this-&gt;boundingBox[$max])
            &amp;&amp; $this-&gt;boundingBox[$max] != 0.0 // phpcs:ignore SlevomatCodingStandard.Operators.DisallowEqualOperators
            &amp;&amp; ($this-&gt;boundingBox[$max] &gt;= $data[$max])
        ) {
            return;
        }

        $this-&gt;boundingBox[$max] = $data[$max];
    }

    /**
     * Adds record to shape file.
     *
     * @return int Number of added record
     */
    public function addRecord(ShapeRecord $record): int
    {
        if ($this-&gt;dbfHeader !== null) {
            $record-&gt;updateDBFInfo($this-&gt;dbfHeader);
        }

        $this-&gt;fileLength += $record-&gt;getContentLength() + 4;
        $this-&gt;records[] = $record;
        $this-&gt;records[count($this-&gt;records) - 1]-&gt;recordNumber = count($this-&gt;records);

        $this-&gt;updateBBox('x', $record-&gt;shpData);
        $this-&gt;updateBBox('y', $record-&gt;shpData);

        if (in_array($this-&gt;shapeType, [11, 13, 15, 18, 21, 23, 25, 28])) {
            $this-&gt;updateBBox('m', $record-&gt;shpData);
        }

        if (in_array($this-&gt;shapeType, [11, 13, 15, 18])) {
            $this-&gt;updateBBox('z', $record-&gt;shpData);
        }

        return count($this-&gt;records) - 1;
    }

    /**
     * Deletes record from shapefile.
     */
    public function deleteRecord(int $index): void
    {
        if (! isset($this-&gt;records[$index])) {
            return;
        }

        $this-&gt;fileLength -= $this-&gt;records[$index]-&gt;getContentLength() + 4;
        $count = count($this-&gt;records) - 1;
        for ($i = $index; $i &lt; $count; ++$i) {
            $this-&gt;records[$i] = $this-&gt;records[$i + 1];
        }

        unset($this-&gt;records[count($this-&gt;records) - 1]);
        $this-&gt;deleteRecordFromDBF($index);
    }

    /**
     * Returns array defining fields in DBF file.
     *
     * @return array|null see setDBFHeader for more information
     */
    public function getDBFHeader(): ?array
    {
        return $this-&gt;dbfHeader;
    }

    /**
     * Changes array defining fields in DBF file, used in dbase_create call.
     *
     * @param array $header An array of arrays, each array describing the
     *                      format of one field of the database. Each
     *                      field consists of a name, a character indicating
     *                      the field type, and optionally, a length,
     *                      a precision and a nullable flag.
     */
    public function setDBFHeader(array $header): void
    {
        $this-&gt;dbfHeader = $header;

        $count = count($this-&gt;records);
        for ($i = 0; $i &lt; $count; ++$i) {
            $this-&gt;records[$i]-&gt;updateDBFInfo($header);
        }
    }

    /**
     * Lookups value in the DBF file and returns index.
     *
     * @param string $field Field to match
     * @param mixed  $value Value to match
     */
    public function getIndexFromDBFData(string $field, $value): int
    {
        foreach ($this-&gt;records as $index =&gt; $record) {
            if (
                isset($record-&gt;dbfData[$field]) &amp;&amp;
                (trim(strtoupper($record-&gt;dbfData[$field])) === strtoupper($value))
            ) {
                return $index;
            }
        }

        return -1;
    }

    /**
     * Loads DBF metadata.
     */
    private function loadDBFHeader(): array
    {
        $DBFFile = fopen($this-&gt;getFilename('.dbf'), 'r');

        $result = [];
        $i = 1;
        $inHeader = true;

        while ($inHeader) {
            if (! feof($DBFFile)) {
                $buff32 = fread($DBFFile, 32);
                if ($i &gt; 1) {
                    if (substr($buff32, 0, 1) === chr(13)) {
                        $inHeader = false;
                    } else {
                        $pos = strpos(substr($buff32, 0, 10), chr(0));
                        $pos = ($pos === false ? 10 : $pos);

                        $fieldName = substr($buff32, 0, $pos);
                        $fieldType = substr($buff32, 11, 1);
                        $fieldLen = ord(substr($buff32, 16, 1));
                        $fieldDec = ord(substr($buff32, 17, 1));

                        array_push($result, [$fieldName, $fieldType, $fieldLen, $fieldDec]);
                    }
                }

                ++$i;
            } else {
                $inHeader = false;
            }
        }

        fclose($DBFFile);

        return $result;
    }

    /**
     * Deletes record from the DBF file.
     */
    private function deleteRecordFromDBF(int $index): void
    {
        if ($this-&gt;dbfFile === null || ! @dbase_delete_record($this-&gt;dbfFile, $index)) {
            return;
        }

        dbase_pack($this-&gt;dbfFile);
    }

    /**
     * Loads SHP file metadata.
     */
    private function loadHeaders(): bool
    {
        if (Util::loadData('N', $this-&gt;readSHP(4)) !== self::MAGIC) {
            $this-&gt;setError('Not a SHP file (file code mismatch)');

            return false;
        }

        /* Skip 20 unused bytes */
        $this-&gt;readSHP(20);

        $this-&gt;fileLength = Util::loadData('N', $this-&gt;readSHP(4));

        /* We currently ignore version */
        $this-&gt;readSHP(4);

        $this-&gt;shapeType = Util::loadData('V', $this-&gt;readSHP(4));

        $this-&gt;boundingBox = [];
        $this-&gt;boundingBox['xmin'] = Util::loadData('d', $this-&gt;readSHP(8));
        $this-&gt;boundingBox['ymin'] = Util::loadData('d', $this-&gt;readSHP(8));
        $this-&gt;boundingBox['xmax'] = Util::loadData('d', $this-&gt;readSHP(8));
        $this-&gt;boundingBox['ymax'] = Util::loadData('d', $this-&gt;readSHP(8));
        $this-&gt;boundingBox['zmin'] = Util::loadData('d', $this-&gt;readSHP(8));
        $this-&gt;boundingBox['zmax'] = Util::loadData('d', $this-&gt;readSHP(8));
        $this-&gt;boundingBox['mmin'] = Util::loadData('d', $this-&gt;readSHP(8));
        $this-&gt;boundingBox['mmax'] = Util::loadData('d', $this-&gt;readSHP(8));

        if (self::supportsDbase()) {
            $this-&gt;dbfHeader = $this-&gt;loadDBFHeader();
        }

        return true;
    }

    /**
     * Saves bounding box record, possibly using 0 instead of not set values.
     *
     * @param resource $file File object
     * @param string   $type Bounding box dimension (eg. xmax, mmin...)
     */
    private function saveBBoxRecord($file, string $type): void
    {
        fwrite($file, Util::packDouble(
            $this-&gt;boundingBox[$type] ?? 0
        ));
    }

    /**
     * Saves bounding box to a file.
     *
     * @param resource $file File object
     */
    private function saveBBox($file): void
    {
        $this-&gt;saveBBoxRecord($file, 'xmin');
        $this-&gt;saveBBoxRecord($file, 'ymin');
        $this-&gt;saveBBoxRecord($file, 'xmax');
        $this-&gt;saveBBoxRecord($file, 'ymax');
        $this-&gt;saveBBoxRecord($file, 'zmin');
        $this-&gt;saveBBoxRecord($file, 'zmax');
        $this-&gt;saveBBoxRecord($file, 'mmin');
        $this-&gt;saveBBoxRecord($file, 'mmax');
    }

    /**
     * Saves SHP and SHX file metadata.
     */
    private function saveHeaders(): void
    {
        fwrite($this-&gt;shpFile, pack('NNNNNN', self::MAGIC, 0, 0, 0, 0, 0));
        fwrite($this-&gt;shpFile, pack('N', $this-&gt;fileLength));
        fwrite($this-&gt;shpFile, pack('V', 1000));
        fwrite($this-&gt;shpFile, pack('V', $this-&gt;shapeType));
        $this-&gt;saveBBox($this-&gt;shpFile);

        fwrite($this-&gt;shxFile, pack('NNNNNN', self::MAGIC, 0, 0, 0, 0, 0));
        fwrite($this-&gt;shxFile, pack('N', 50 + 4 * count($this-&gt;records)));
        fwrite($this-&gt;shxFile, pack('V', 1000));
        fwrite($this-&gt;shxFile, pack('V', $this-&gt;shapeType));
        $this-&gt;saveBBox($this-&gt;shxFile);
    }

    /**
     * Loads records from SHP file (and DBF).
     */
    private function loadRecords(): bool
    {
        /* Need to start at offset 100 */
        while (! $this-&gt;eofSHP()) {
            $record = new ShapeRecord(-1);
            $record-&gt;loadFromFile($this, $this-&gt;shpFile, $this-&gt;dbfFile);
            if ($record-&gt;lastError !== '') {
                $this-&gt;setError($record-&gt;lastError);

                return false;
            }

            if (($record-&gt;shapeType === false || $record-&gt;shapeType === '') &amp;&amp; $this-&gt;eofSHP()) {
                break;
            }

            $this-&gt;records[] = $record;
        }

        return true;
    }

    /**
     * Saves records to SHP and SHX files.
     */
    private function saveRecords(): void
    {
        $offset = 50;
        if (! is_array($this-&gt;records) || (count($this-&gt;records) &lt;= 0)) {
            return;
        }

        foreach ($this-&gt;records as $index =&gt; $record) {
            //Save the record to the .shp file
            $record-&gt;saveToFile($this-&gt;shpFile, $this-&gt;dbfFile, $index + 1);

            //Save the record to the .shx file
            fwrite($this-&gt;shxFile, pack('N', $offset));
            fwrite($this-&gt;shxFile, pack('N', $record-&gt;getContentLength()));
            $offset += 4 + $record-&gt;getContentLength();
        }
    }

    /**
     * Generic interface to open files.
     *
     * @param bool   $toWrite   Whether file should be opened for writing
     * @param string $extension File extension
     * @param string $name      Verbose file name to report errors
     *
     * @return resource|false File handle
     */
    private function openFile(bool $toWrite, string $extension, string $name)
    {
        $shpName = $this-&gt;getFilename($extension);
        $result = @fopen($shpName, ($toWrite ? 'wb+' : 'rb'));
        if (! $result) {
            $this-&gt;setError(sprintf('It wasn\'t possible to open the %s file &quot;%s&quot;', $name, $shpName));

            return false;
        }

        return $result;
    }

    /**
     * Opens SHP file.
     *
     * @param bool $toWrite Whether file should be opened for writing
     */
    private function openSHPFile(bool $toWrite = false): bool
    {
        $this-&gt;shpFile = $this-&gt;openFile($toWrite, '.shp', 'Shape');

        return (bool) $this-&gt;shpFile;
    }

    /**
     * Closes SHP file.
     */
    private function closeSHPFile(): void
    {
        if (! $this-&gt;shpFile) {
            return;
        }

        fclose($this-&gt;shpFile);
        $this-&gt;shpFile = null;
    }

    /**
     * Opens SHX file.
     *
     * @param bool $toWrite Whether file should be opened for writing
     */
    private function openSHXFile(bool $toWrite = false): bool
    {
        $this-&gt;shxFile = $this-&gt;openFile($toWrite, '.shx', 'Index');

        return (bool) $this-&gt;shxFile;
    }

    /**
     * Closes SHX file.
     */
    private function closeSHXFile(): void
    {
        if (! $this-&gt;shxFile) {
            return;
        }

        fclose($this-&gt;shxFile);
        $this-&gt;shxFile = null;
    }

    /**
     * Creates DBF file.
     */
    private function createDBFFile(): bool
    {
        if (! self::supportsDbase() || ! is_array($this-&gt;dbfHeader) || count($this-&gt;dbfHeader) === 0) {
            $this-&gt;dbfFile = null;

            return true;
        }

        $dbfName = $this-&gt;getFilename('.dbf');

        /* Unlink existing file */
        if (file_exists($dbfName)) {
            unlink($dbfName);
        }

        /* Create new file */
        $this-&gt;dbfFile = @dbase_create($dbfName, $this-&gt;dbfHeader);
        if ($this-&gt;dbfFile === false) {
            $this-&gt;setError(sprintf('It wasn\'t possible to create the DBase file &quot;%s&quot;', $dbfName));

            return false;
        }

        return true;
    }

    /**
     * Loads DBF file if supported.
     */
    private function openDBFFile(): bool
    {
        if (! self::supportsDbase()) {
            $this-&gt;dbfFile = null;

            return true;
        }

        $dbfName = $this-&gt;getFilename('.dbf');
        if (! is_readable($dbfName)) {
            $this-&gt;setError(sprintf('It wasn\'t possible to find the DBase file &quot;%s&quot;', $dbfName));

            return false;
        }

        $this-&gt;dbfFile = @dbase_open($dbfName, 0);
        if (! $this-&gt;dbfFile) {
            $this-&gt;setError(sprintf('It wasn\'t possible to open the DBase file &quot;%s&quot;', $dbfName));

            return false;
        }

        return true;
    }

    /**
     * Closes DBF file.
     */
    private function closeDBFFile(): void
    {
        if (! $this-&gt;dbfFile) {
            return;
        }

        dbase_close($this-&gt;dbfFile);
        $this-&gt;dbfFile = null;
    }

    /**
     * Sets error message.
     */
    public function setError(string $error): void
    {
        $this-&gt;lastError = $error;
    }

    /**
     * Reads given number of bytes from SHP file.
     *
     * @return string|false
     */
    public function readSHP(int $bytes)
    {
        if ($this-&gt;shpFile === null) {
            return false;
        }

        return fread($this-&gt;shpFile, $bytes);
    }

    /**
     * Checks whether file is at EOF.
     */
    public function eofSHP(): bool
    {
        return feof($this-&gt;shpFile);
    }

    /**
     * Returns shape name.
     */
    public function getShapeName(): string
    {
        return Util::nameShape($this-&gt;shapeType);
    }

    /**
     * Check whether file contains measure data.
     *
     * For some reason this is distinguished by zero bounding box in the
     * specification.
     */
    public function hasMeasure(): bool
    {
        // phpcs:ignore SlevomatCodingStandard.Operators.DisallowEqualOperators.DisallowedNotEqualOperator
        return $this-&gt;boundingBox['mmin'] != 0 || $this-&gt;boundingBox['mmax'] != 0;
    }
}
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flocal%2Fcpanel%2Fbase%2F3rdparty%2FphpMyAdmin%2Fvendor%2Fphpmyadmin%2Fshapefile%2Fsrc'>Back to Directory</a>