Gazelle/classes/bencodedecode.class.php

<?php

/**
 * The decode class is simple and straightforward. The only thing to
 * note is that empty dictionaries are represented by boolean trues
 */
class BencodeDecode extends Bencode
{
    private $Data;
    private $Length;
    private $Pos = 0;
    public $Dec = [];
    public $ExitOnError = true;
    const SnipLength = 40;

    /**
     * Decode prepararations
     *
     * @param string $Arg bencoded string or path to bencoded file to decode
     * @param bool $IsPath needs to be true if $Arg is a path
     * @return decoded data with a suitable structure
     */
    public function __construct($Arg = false, $IsPath = false, $Strict = true)
    {
        if (!$Strict) {
            $this->ExitOnError = false;
        }

        if ($Arg === false) {
            if (empty($this->Enc)) {
                return false;
            }
        } else {
            if ($IsPath === true) {
                return $this->bdec_file($Arg);
            }
            $this->Data = $Arg;
        }
        return $this->decode();
    }

    /**
     * Decodes a bencoded file
     *
     * @param $Path path to bencoded file to decode
     * @return decoded data with a suitable structure
     */
    public function bdec_file($Path = false)
    {
        if (empty($Path)) {
            return false;
        }

        if (!$this->Data = @file_get_contents($Path, FILE_BINARY)) {
            return $this->error("Error: file '$Path' could not be opened.\n");
        }
        return $this->decode();
    }

    /**
     * Decodes a string with bencoded data
     *
     * @param mixed $Arg bencoded data or false to decode the content of $this->Data
     * @return decoded data with a suitable structure
     */
    public function decode($Arg = false)
    {
        if ($Arg !== false) {
            $this->Data = $Arg;
        } elseif (!$this->Data) {
            $this->Data = $this->Enc;
        }

        if (!$this->Data) {
            return false;
        }

        $this->Length = strlen($this->Data);
        $this->Pos = 0;
        $this->Dec = $this->_bdec();

        if ($this->Pos < $this->Length) {
            // Not really necessary, but if the torrent is invalid, it's better to warn than to silently truncate it
            return $this->error();
        }
        return $this->Dec;
    }

    /**
     * Internal decoding function that does the actual job
     *
     * @return decoded data with a suitable structure
     */
    private function _bdec()
    {
        switch ($this->Data[$this->Pos]) {

      case 'i':
        $this->Pos++;
        $Value = substr($this->Data, $this->Pos, strpos($this->Data, 'e', $this->Pos) - $this->Pos);
        if (!ctype_digit($Value) && !($Value[0] == '-' && ctype_digit(substr($Value, 1)))) {
            return $this->error();
        }
        $this->Pos += strlen($Value) + 1;
        return Int64::make($Value);

      case 'l':
        $Value = [];
        $this->Pos++;
        while ($this->Data[$this->Pos] != 'e') {
            if ($this->Pos >= $this->Length) {
                return $this->error();
            }
            $Value[] = $this->_bdec();
        }
        $this->Pos++;
        return $Value;

      case 'd':
        $Value = [];
        $this->Pos++;
        while ($this->Data[$this->Pos] != 'e') {
            $Length = substr($this->Data, $this->Pos, strpos($this->Data, ':', $this->Pos) - $this->Pos);
            if (!ctype_digit($Length)) {
                return $this->error();
            }
            $this->Pos += strlen($Length) + $Length + 1;
            $Key = substr($this->Data, $this->Pos - $Length, $Length);
            if ($this->Pos >= $this->Length) {
                return $this->error();
            }
            $Value[$Key] = $this->_bdec();
        }
        $this->Pos++;
        // Use boolean true to keep track of empty dictionaries
        return empty($Value) ? true : $Value;

      default:
        $Length = substr($this->Data, $this->Pos, strpos($this->Data, ':', $this->Pos) - $this->Pos);
        if (!ctype_digit($Length)) {
            return $this->error(); // Even if the string is likely to be decoded correctly without this check, it's malformed
        }
        $this->Pos += strlen($Length) + $Length + 1;
        return substr($this->Data, $this->Pos - $Length, $Length);
    }
    }

    /**
     * Convert everything to the correct data types and optionally escape strings
     *
     * @param bool $Escape whether to escape the textual data
     * @param mixed $Data decoded data or false to use the $Dec property
     * @return decoded data with more useful data types
     */
    public function dump($Escape = true, $Data = false)
    {
        if ($Data === false) {
            $Data = $this->Dec;
        }

        if (Int64::is_int($Data)) {
            return Int64::get($Data);
        }

        if (is_bool($Data)) {
            return [];
        }

        if (is_array($Data)) {
            $Output = [];
            foreach ($Data as $Key => $Val) {
                $Output[$Key] = $this->dump($Escape, $Val);
            }
            return $Output;
        }
        return $Escape ? htmlentities($Data) : $Data;
    }

    /**
     * Display an error and halt the operation unless the $ExitOnError property is false
     *
     * @param string $ErrMsg the error message to display
     */
    private function error($ErrMsg = false)
    {
        static $ErrorPos;
        if ($this->Pos === $ErrorPos) {
            // The recursive nature of the class requires this to avoid duplicate error messages
            return false;
        }

        if ($this->ExitOnError) {
            if ($ErrMsg === false) {
                printf(
                    "Malformed string. Invalid character at pos 0x%X: %s\n",
                    $this->Pos,
                    str_replace(array("\r","\n"), array('',' '), htmlentities(substr($this->Data, $this->Pos, self::SnipLength)))
                );
            } else {
                echo $ErrMsg;
            }
            exit();
        }
        
        $ErrorPos = $this->Pos;
        return false;
    }
}