PHP Binary Class

    PHP Binary Class

    Hallööle..
    Ich hab mir mal just4fun ne Binary Class in PHP gemacht
    Hier der code:

    PHP-Quellcode

    1. <?php
    3. class BinaryReader
    4. {
    6. protected $arrBytes = array();
    7. public function getBytes()
    8. {
    9. return $this->arrBytes;
    10. }
    12. protected $intIndex = 0;
    13. public function getIndex()
    14. {
    15. return $this->intIndex;
    16. }
    17. public function seekIndex($intSeek, $boolBackward = false)
    18. {
    19. $intMixReturn = false;
    20. if(is_numeric($intSeek) && $intSeek >= 0)
    21. {
    22. if(!$boolBackward && ($this->intIndex + $intSeek) <= count($this->arrBytes))
    23. {
    24. $this->intIndex += $intSeek;
    25. $intMixReturn = $this->intIndex;
    26. }
    27. elseif($boolBackward && ($this->intIndex - $intSeek) >= 0)
    28. {
    29. $this->intIndex -= $intSeek;
    30. $intMixReturn = $this->intIndex;
    31. }
    32. }
    33. return $intMixReturn;
    34. }
    36. function __construct($mixInput)
    37. {
    38. $this->intIndex = 0;
    39. $this->arrBytes = array();
    40. if(is_array($mixInput))
    41. {
    42. $this->arrBytes = $mixInput;
    43. }
    44. elseif(is_string($mixInput))
    45. {
    46. for($intIndex = 0; $intIndex < strlen($mixInput); $intIndex ++)
    47. {
    48. $this->arrBytes[] = ord($mixInput[$intIndex]);
    49. }
    50. }
    51. else
    52. {
    53. return false;
    54. }
    55. }
    57. public function canRead($intUnit = 1)
    58. {
    59. if(($this->intIndex + $intUnit) <= count($this->arrBytes))
    60. {
    61. return true;
    62. }
    63. else
    64. {
    65. return false;
    66. }
    67. }
    69. public function readByte()
    70. {
    71. if($this->canRead(1))
    72. {
    73. $intTempByte = $this->arrBytes[$this->intIndex];
    74. $this->intIndex += 1;
    75. return $intTempByte;
    76. }
    77. else
    78. {
    79. return false;
    80. }
    81. }
    82. public function readShort()
    83. {
    84. if($this->canRead(2))
    85. {
    86. $intTempShort = BinaryHelper::GetShortFromBytes(array($this->arrBytes[$this->intIndex], $this->arrBytes[$this->intIndex + 1]));
    87. $this->intIndex += 2;
    88. return $intTempShort;
    89. }
    90. else
    91. {
    92. return false;
    93. }
    94. }
    95. public function readInteger()
    96. {
    97. if($this->canRead(4))
    98. {
    99. $intTempShort = BinaryHelper::GetIntegerFromBytes(array($this->arrBytes[$this->intIndex], $this->arrBytes[$this->intIndex + 1], $this->arrBytes[$this->intIndex + 2], $this->arrBytes[$this->intIndex + 3]));
    100. $this->intIndex += 4;
    101. return $intTempShort;
    102. }
    103. else
    104. {
    105. return false;
    106. }
    107. }
    108. public function readString()
    109. {
    110. $intLength = $this->readInteger();
    111. if($intLength !== false)
    112. {
    113. if($this->canRead($intLength))
    114. {
    115. $strTempString = "";
    116. for($intIndex = 0; $intIndex < $intLength; $intIndex ++)
    117. {
    118. $strTempString .= chr($this->readByte());
    119. }
    120. return $strTempString;
    121. }
    122. else
    123. {
    124. return false;
    125. }
    126. }
    127. else
    128. {
    129. return false;
    130. }
    131. }
    133. }
    135. class BinaryWriter
    136. {
    138. protected $arrBytes = array();
    139. public function getBytes()
    140. {
    141. return $this->arrBytes;
    142. }
    143. public function getBytesString()
    144. {
    145. $strFinalString = "";
    146. for($intIndex = 0; $intIndex < count($this->arrBytes); $intIndex ++)
    147. {
    148. $strFinalString .= chr($this->arrBytes[$intIndex]);
    149. }
    150. return $strFinalString;
    151. }
    152. public function getBytesHex()
    153. {
    154. $strFinalString = "";
    155. for($intIndex = 0; $intIndex < count($this->arrBytes); $intIndex ++)
    156. {
    157. $strTempString = strtoupper(dechex($this->arrBytes[$intIndex]));
    158. $strTempString = substr("00", 0, 2 - strlen($strTempString)).$strTempString;
    159. $strFinalString .= $strTempString." ";
    160. }
    161. return $strFinalString;
    162. }
    164. function __construct()
    165. {
    166. $this->arrBytes = array();
    167. }
    169. public function writeByte($intByte)
    170. {
    171. $intBytes = BinaryHelper::GetByteFromByte($intByte);
    172. $this->arrBytes[] = $intBytes[0];
    173. }
    175. public function writeString($strWrite)
    176. {
    177. $intStringLengthBytes = BinaryHelper::GetBytesFromInteger(strlen($strWrite));
    178. $this->arrBytes[] = $intStringLengthBytes[0];
    179. $this->arrBytes[] = $intStringLengthBytes[1];
    180. $this->arrBytes[] = $intStringLengthBytes[2];
    181. $this->arrBytes[] = $intStringLengthBytes[3];
    182. for($intIndex = 0; $intIndex < strlen($strWrite); $intIndex ++)
    183. {
    184. $this->arrBytes[] = ord($strWrite[$intIndex]);
    185. }
    186. }
    187. public function writeInteger($intWrite)
    188. {
    189. $intIntegerBytes = BinaryHelper::GetBytesFromInteger($intWrite);
    190. foreach($intIntegerBytes as $intIntegerByte)
    191. {
    192. $this->arrBytes[] = $intIntegerByte;
    193. }
    194. }
    195. public function writeShort($intWrite)
    196. {
    197. $intShortBytes = BinaryHelper::GetBytesFromShort($intWrite);
    198. foreach($intShortBytes as $intShortByte)
    199. {
    200. $this->arrBytes[] = $intShortByte;
    201. }
    202. }
    203. /*public function writeLong($intWrite)
    204. {
    205. $intLongBytes = BinaryHelper::GetBytesFromLong($intWrite);
    206. foreach($intLongBytes as $intLongByte)
    207. {
    208. $this->arrBytes[] = $intLongByte;
    209. }
    210. }*/
    212. }
    214. class BinaryHelper
    215. {
    217. public static function GetBytesFromInteger($intInteger)
    218. {
    219. $BitSequence = decbin($intInteger);
    220. $BitSequence = substr("00000000000000000000000000000000", 0, 32 - strlen($BitSequence)).$BitSequence;
    221. $BitSequence = substr($BitSequence, 0, 32);
    222. $arrBytes = array();
    223. $arrBytes[] = bindec(substr($BitSequence, 0, 8));
    224. $arrBytes[] = bindec(substr($BitSequence, 8, 8));
    225. $arrBytes[] = bindec(substr($BitSequence, 16, 8));
    226. $arrBytes[] = bindec(substr($BitSequence, 24, 8));
    227. return $arrBytes;
    228. }
    229. public static function GetByteFromByte($intByte)
    230. {
    231. $BitSequence = decbin($intByte);
    232. $BitSequence = substr("00000000", 0, 8 - strlen($BitSequence)).$BitSequence;
    233. $BitSequence = substr($BitSequence, 0, 8);
    234. $arrBytes = array();
    235. $arrBytes[] = bindec(substr($BitSequence, 0, 8));
    236. return $arrBytes;
    237. }
    238. public static function GetBytesFromShort($intShort)
    239. {
    240. $BitSequence = decbin($intShort);
    241. $BitSequence = substr("0000000000000000", 0, 16 - strlen($BitSequence)).$BitSequence;
    242. $BitSequence = substr($BitSequence, 0, 16);
    243. $arrBytes = array();
    244. $arrBytes[] = bindec(substr($BitSequence, 0, 8));
    245. $arrBytes[] = bindec(substr($BitSequence, 8, 8));
    246. return $arrBytes;
    247. }
    248. public static function GetBytesFromLong($intLong)
    249. {
    250. $BitSequence = decbin($intLong);
    251. $BitSequence = substr("0000000000000000000000000000000000000000000000000000000000000000", 0, 64 - strlen($BitSequence)).$BitSequence;
    252. $BitSequence = substr($BitSequence, 0, 64);
    253. $arrBytes = array();
    254. $arrBytes[] = bindec(substr($BitSequence, 0, 8));
    255. $arrBytes[] = bindec(substr($BitSequence, 8, 8));
    256. $arrBytes[] = bindec(substr($BitSequence, 16, 8));
    257. $arrBytes[] = bindec(substr($BitSequence, 24, 8));
    258. $arrBytes[] = bindec(substr($BitSequence, 32, 8));
    259. $arrBytes[] = bindec(substr($BitSequence, 40, 8));
    260. $arrBytes[] = bindec(substr($BitSequence, 48, 8));
    261. $arrBytes[] = bindec(substr($BitSequence, 56, 8));
    262. return $arrBytes;
    263. }
    265. public static function GetLongFromBytes($arrBytes)
    266. {
    267. if(count($arrBytes) != 8) { return false; }
    268. $BitSequence = "";
    269. for($intIndex = 0; $intIndex < 8; $intIndex ++)
    270. {
    271. $BitSequenceTemp = decbin($arrBytes[$intIndex]);
    272. $BitSequence .= substr("00000000", 0, 8 - strlen($BitSequenceTemp)).$BitSequenceTemp;
    273. }
    274. return bindec($BitSequence);
    275. }
    276. public static function GetIntegerFromBytes($arrBytes)
    277. {
    278. if(count($arrBytes) != 4) { return false; }
    279. $BitSequence = "";
    280. for($intIndex = 0; $intIndex < 4; $intIndex ++)
    281. {
    282. $BitSequenceTemp = decbin($arrBytes[$intIndex]);
    283. $BitSequence .= substr("00000000", 0, 8 - strlen($BitSequenceTemp)).$BitSequenceTemp;
    284. }
    285. return bindec($BitSequence);
    286. }
    287. public static function GetShortFromBytes($arrBytes)
    288. {
    289. if(count($arrBytes) != 2) { return false; }
    290. $BitSequence = "";
    291. for($intIndex = 0; $intIndex < 2; $intIndex ++)
    292. {
    293. $BitSequenceTemp = decbin($arrBytes[$intIndex]);
    294. $BitSequence .= substr("00000000", 0, 8 - strlen($BitSequenceTemp)).$BitSequenceTemp;
    295. }
    296. return bindec($BitSequence);
    297. }
    299. }
    302. ?>


    Viel spaß!

Facebook