<?php
/*
Bencoding OOP wrapper for PHP | by Proger_XP | In public domain
http://proger.i-forge.net/BEncoded/7Tn
Based on lightenc.php functions from
http://wiki.theory.org/Decoding_encoding_bencoded_data_with_PHP
*/
/* BEncoded classes by Proger_XP */
class BEncoded {
public $nodes;
public $tempChar;
static function Decode($str) {
$res = bdecode($str);
if ($res === null) {
throw new EBEncode(null, 'Cannot decode bencoded data.', 'string: '.$str);
} else {
return $res;
}
}
static function Encode($data, $tempChar = null) {
$res = bencode($data, $tempChar);
if ($res === null) {
throw new EBEncode(null, 'Cannot encode bencoded data of type '.gettype($data).'.');
}
return $res;
}
static function TypeOf($value) {
if (is_scalar($value) or $value === null) {
return ((is_int($value) or is_float($value)) ? 'int' : 'str');
} else {
return empty($value['isDct']) ? 'list' : 'dict';
}
}
static function HashOf($nodes, $raw = false) {
return strtoupper(sha1(self::Encode($nodes), $raw));
}
/* Instance methods */
function __construct($str = null) {
if ($str !== null) {
$this->FromString($str);
}
}
function FromString($str) {
$nodes = self::Decode($str);
if (!is_array($nodes)) {
throw new EBEncode($this, 'Cannot load bencoded string - it decodes to'.
' a non-array ('.gettype($nodes).').');
}
$this->nodes = &$nodes;
}
function FromFile($file) {
$str = file_get_contents($file);
if (!is_string($str)) {
throw new EBEncode($this, 'File to load bencoded file from doesn\'t exist.', 'file: '.$file);
}
$this->FromString($str);
}
function ToString() {
return self::Encode($this->nodes, $this->tempChar);
}
function ToFile($file) {
$bytes = file_put_contents($file, $this->ToString, LOCK_EX);
if (!is_int($bytes)) {
throw new EBEncode($this, 'Cannot save bencoded file.', 'dest file: '.$file);
}
return $bytes;
}
// returns a shallow copy of root; to operate directly $this->nodes can be used.
function Root() { return $this->nodes; }
// returns null if node doesn't exist. $name = "/" or "" returns (sets/deletes) root.
function ValueOf($name) { return $this->Alter($name); }
// alias to ValueOf():
function Get($name) { return $this->ValueOf($name); }
function Set($name, $value) { return $this->Alter($name, 'set', $value); }
function Copy($src, $dest) { return $this->Set($dest, $this->ValueOf($src)); }
function Exchange($node_1, $node_2) {
$temp = $this->ValueOf($node_2);
$this->Set($node_2, $this->ValueOf($node_1));
$this->Set($node_1, $temp);
}
function Delete($name) { return $this->Alter($name, 'delete'); }
// $op: (g)et / (s)et, returns new value / (d)elete.
protected function Alter($name, $op = 'get', $arg = null) {
$lastSlash = strpbrk(mb_substr($name, -1), '\\/');
$name = trim( strtr($name, '\\', '/'), '/' );
$path = $name === '' ? array() : explode('/', $name);
$parent = &$this->nodes;
while ($path and is_array($parent)) {
$value = &$parent[array_shift($path)];
if ($op[0] === 'd') {
if (!$path and $lastSlash == is_array($value)) {
$value = null;
}
} elseif ($op[0] === 's') {
if ($value === null and $path) {
$value = array();
if (( (string) $path[0] ) !== '0') {
$value['isDct'] = true;
}
}
}
$parent = &$value;
}
if ($op[0] === 's') {
$parent = $arg;
} elseif ($op[0] === 'd' and !$name) {
$parent = array();
}
return $parent;
}
function Export($name = '') { return $this->Dump( $this->ValueOf($name) ); }
function Dump($value, $prefix = '') {
$type = self::TypeOf($value);
if ($type === 'int') {
return is_float($value) ? sprintf('%1.1f', $value) : $value;
} elseif ($type === 'str') {
return var_export($value, true);
} else {
$res = '';
$isDict = $type === 'dict';
foreach ($value as $key => &$item) {
if (!bskip($key, $item, $this->tempChar)) {
$res .= $prefix;
$res .= $isDict ? "$key:" : "#$key";
$res .= is_array($item) ? "\n" : ' ';
$res .= $this->Dump($item, "$prefix ")."\n";
}
}
return substr($res, 0, -1);
}
}
// type: int|str|list|dict; other type throws exception.
function NewNode($type, $name) {
switch ($type = strtolower($type)) {
case 'int': return $this->Set($name, 0);
case 'str': return $this->Set($name, '');
case 'list': return $this->Set($name, array());
case 'dict': return $this->Set($name, array('isDct' => true));
default: throw new EBEncode($this, 'Cannot create bencoded node because type '.$type.' is unknown.');
}
}
function SetEmpty($name) {
$value = $this->ValueOf($name);
if (is_int($value) or is_float($value)) {
$value = 0;
} elseif (is_string($value) or $value === null) {
$value = '';
} elseif (empty($value['isDct'])) {
$value = array();
} else {
$value = array('isDct' => true);
}
return $this->Set($name, $value);
}
function Cast($name, $asType, $onlyIfNum = false) {
$value = $this->ValueOf($name);
if ($value === null) {
throw new EBEncode($this, 'Cannot cast node '.$name.' into '.$asType.' because node doesn\'t exist.');
}
$asType = strtolower($asType);
if (!in_array($asType, array('int', 'str', 'list', 'dict'))) {
throw new EBEncode($this, 'Cannot cast node "'.$name.'" because new type ('.$asType.') is invalid.');
}
$type = self::TypeOf($value);
if ($type !== $asType) {
if ($type === 'int' or $type === 'str') {
switch ($asType) {
// str -> int:
case 'int':
if (!is_numeric($value)) {
if (!$onlyIfNum) {
throw new EBEncode($this, 'Cannot cast string "'.$value.' to integer because it\'s not a number.');
}
} else {
$value = (float) $value;
}
break;
// int -> str:
case 'str': $value = (string) $value; break;
case 'list': $value = array(0 => $value); break;
case 'dict': $value = array('isDct' => true, 0 => $value); break;
}
} elseif ($asType === 'int' or $asType === 'str') {
throw new EBException($this, 'Casting list/dict node "'.$name.'" into int/str isn\'t allowed.');
} elseif ($asType === 'dict') { // list -> dict
$value['isDct'] = true;
} else { // dict -> list
unset($value['isDct']);
}
$this->Set($name, $value);
}
return $value;
}
function TempChar($new = null) {
$new === null or $this->tempChar = $new === '' ? null : $new;
return $this->tempChar;
}
function InfoHash($raw = false) {
$info = &$this->nodes['info'];
if (empty($info)) {
throw new EBEncode($this, 'Cannot calculate info hash because there is no \'info\' dictionary.');
} else {
return self::HashOf($info, $raw);
}
}
}
class EBEncode extends Exception {
public $obj;
function __construct($bencObj, $msg, $details = '', $previous = null) {
$this->obj = $bencObj;
parent::__construct(rtrim($msg, '.').": $details", $previous);
}
}
/* lightenc.php */
function bdecode($s, &$pos=0) {
if($pos>=strlen($s)) {
return null;
}
switch($s[$pos]){
case 'd':
$pos++;
$retval=array();
while ($s[$pos]!='e'){
$key=bdecode($s, $pos);
$val=bdecode($s, $pos);
if ($key===null || $val===null)
break;
$retval[$key]=$val;
}
$retval["isDct"]=true;
$pos++;
return $retval;
case 'l':
$pos++;
$retval=array();
while ($s[$pos]!='e'){
$val=bdecode($s, $pos);
if ($val===null)
break;
$retval[]=$val;
}
$pos++;
return $retval;
case 'i':
$pos++;
$digits=strpos($s, 'e', $pos)-$pos;
// Proger_XP: changed (int) -> (float) to avoid trimming of values exceeding
// signed int's max value (2147483647).
$val=(float)substr($s, $pos, $digits);
$pos+=$digits+1;
return $val;
// case "0": case "1": case "2": case "3": case "4":
// case "5": case "6": case "7": case "8": case "9":
default:
$digits=strpos($s, ':', $pos)-$pos;
if ($digits<0 || $digits >20)
return null;
$len=(float)substr($s, $pos, $digits);
$pos+=$digits+1;
$str=substr($s, $pos, $len);
$pos+=$len;
//echo "pos: $pos str: [$str] len: $len digits: $digits\n";
return (string)$str;
}
return null;
}
// Proger_XP: added added skipping for null values and $tempChar prefix for list/dicts.
function bencode(&$d, $tempChar = null){
if(is_array($d)){
$ret="l";
$isDict=!empty($d["isDct"]);
if($isDict){
$ret="d";
// this is required by the specs, and BitTornado actualy chokes on unsorted dictionaries
ksort($d, SORT_STRING);
}
foreach($d as $key=>$value) {
if($isDict){
// skip the isDct element, only if it's set by us
if (!bskip($key, $value, $tempChar)) {
$ret .= strlen($key).":$key";
}
} elseif (!is_int($key) and !is_float($key) and trim($key, '0..9') !== '') {
// Proger_XP: added exception raising for non-numeric list keys.
throw new EBEncode(null, 'Cannot bencode() a list - it contains a non-numeric key "'.$key.'".');
}
if (is_string($value)) {
$ret.=strlen($value).":".$value;
} elseif (is_int($value) or is_float($value)){
$ret.="i${value}e";
} else {
$ret.=bencode ($value);
}
}
return $ret."e";
} elseif (is_string($d)) { // fallback if we're given a single bencoded string or int
return strlen($d).":".$d;
} elseif (is_int($d) or is_float($d)) {
return "i${d}e";
} else {
return null;
}
}
// bskip by Proger_XP.
function bskip($key, &$value, $tempChar = null) {
return ($key === 'isDct' and $value) or $value === null or strpos($key, $tempChar) === 0;
}
