--- a/lib/Protobuf-PHP/library/DrSlump/Protobuf/Codec/Binary.php +++ b/lib/Protobuf-PHP/library/DrSlump/Protobuf/Codec/Binary.php @@ -1,1 +1,389 @@ - +<?php + +namespace DrSlump\Protobuf\Codec; + +use DrSlump\Protobuf; + +class Binary implements Protobuf\CodecInterface +{ + const WIRE_VARINT = 0; + const WIRE_FIXED64 = 1; + const WIRE_LENGTH = 2; + const WIRE_GROUP_START = 3; + const WIRE_GROUP_END = 4; + const WIRE_FIXED32 = 5; + const WIRE_UNKNOWN = -1; + + /** + * @param \DrSlump\Protobuf\Message $message + * @return string + */ + public function encode(Protobuf\Message $message) + { + return $this->encodeMessage($message); + } + + /** + * @param String|Message $message + * @param String $data + * @return \DrSlump\Protobuf\Message + */ + public function decode(Protobuf\Message $message, $data) + { + return $this->decodeMessage($message, $data); + } + + + protected function encodeMessage(Protobuf\Message $message) + { + $writer = new Binary\Writer(); + + // Get message descriptor + $descriptor = Protobuf::getRegistry()->getDescriptor($message); + + foreach ($descriptor->getFields() as $tag=>$field) { + + $empty = !$message->_has($tag); + if ($field->isRequired() && $empty) { + throw new \UnexpectedValueException( + 'Message ' . get_class($message) . '\'s field tag ' . $tag . '(' . $field->getName() . ') is required but has no value' + ); + } + + // Skip empty fields + if ($empty) { + continue; + } + + $type = $field->getType(); + $wire = $field->isPacked() ? self::WIRE_LENGTH : $this->getWireType($type, null); + + // Compute key with tag number and wire type + $key = $tag << 3 | $wire; + + $value = $message->_get($tag); + + if ($field->isRepeated()) { + + // Packed fields are encoded as a length-delimited stream containing + // the concatenated encoding of each value. + if ($field->isPacked() && !empty($value)) { + $subwriter = new Binary\Writer(); + foreach($value as $val) { + $this->encodeSimpleType($subwriter, $type, $val); + } + $data = $subwriter->getBytes(); + $writer->varint($key); + $writer->varint(strlen($data)); + $writer->write($data); + } else { + foreach($value as $val) { + if ($type !== Protobuf::TYPE_MESSAGE) { + $writer->varint($key); + $this->encodeSimpleType($writer, $type, $val); + } else { + $writer->varint($key); + $data = $this->encodeMessage($val); + $writer->varint(strlen($data)); + $writer->write($data); + } + } + } + } else { + if ($type !== Protobuf::TYPE_MESSAGE) { + $writer->varint($key); + $this->encodeSimpleType($writer, $type, $value); + } else { + $writer->varint($key); + $data = $this->encodeMessage($value); + $writer->varint(strlen($data)); + $writer->write($data); + } + } + } + + return $writer->getBytes(); + } + + protected function encodeSimpleType($writer, $type, $value) + { + switch ($type) { + case Protobuf::TYPE_INT32: + case Protobuf::TYPE_INT64: + case Protobuf::TYPE_UINT64: + case Protobuf::TYPE_UINT32: + $writer->varint($value); + break; + + case Protobuf::TYPE_SINT32: // ZigZag + $writer->zigzag($value, 32); + break; + + case Protobuf::TYPE_SINT64 : // ZigZag + $writer->zigzag($value, 64); + break; + + case Protobuf::TYPE_DOUBLE: + $writer->double($value); + break; + case Protobuf::TYPE_FIXED64: + $writer->fixed64($value); + break; + case Protobuf::TYPE_SFIXED64: + $writer->sFixed64($value); + break; + + case Protobuf::TYPE_FLOAT: + $writer->float($value); + break; + case Protobuf::TYPE_FIXED32: + $writer->fixed32($value); + break; + case Protobuf::TYPE_SFIXED32: + $writer->sFixed32($value); + break; + + case Protobuf::TYPE_BOOL: + $writer->varint($value ? 1 : 0); + break; + + case Protobuf::TYPE_STRING: + case Protobuf::TYPE_BYTES: + $writer->varint(strlen($value)); + $writer->write($value); + break; + + case Protobuf::TYPE_MESSAGE: + // Messages are not supported in this method + return null; + + case Protobuf::TYPE_ENUM: + $writer->varint($value); + break; + + default: + throw new \Exception('Unknown field type ' . $type); + } + } + + + protected function decodeMessage(\DrSlump\Protobuf\Message $message, $data) + { + /** @var $message \DrSlump\Protobuf\Message */ + /** @var $descriptor \DrSlump\Protobuf\Descriptor */ + + // Create a binary reader for the data + $reader = new Protobuf\Codec\Binary\Reader($data); + + // Get message descriptor + $descriptor = Protobuf::getRegistry()->getDescriptor($message); + + while (!$reader->eof()) { + + // Get initial varint with tag number and wire type + $key = $reader->varint(); + if ($reader->eof()) break; + + $wire = $key & 0x7; + $tag = $key >> 3; + + // Find the matching field for the tag number + $field = $descriptor->getField($tag); + if (!$field) { + $data = $this->decodeUnknown($reader, $wire); + $unknown = new Binary\Unknown($tag, $wire, $data); + $message->addUnknown($unknown); + continue; + } + + $type = $field->getType(); + + // Check if we are dealing with a packed stream, we cannot rely on the packed + // flag of the message since we cannot be certain if the creator of the message + // was using it. + if ($wire === self::WIRE_LENGTH && $field->isRepeated() && $this->isPackable($type)) { + $length = $reader->varint(); + $until = $reader->pos() + $length; + while ($reader->pos() < $until) { + $item = $this->decodeSimpleType($reader, $type, self::WIRE_VARINT); + $message->_add($tag, $item); + } + + } else { + + // Assert wire and type match + $this->assertWireType($wire, $type); + + // Check if it's a sub-message + if ($type === Protobuf::TYPE_MESSAGE) { + $submessage = $field->getReference(); + $submessage = new $submessage; + + $length = $this->decodeSimpleType($reader, Protobuf::TYPE_INT64, self::WIRE_VARINT); + $data = $reader->read($length); + + $value = $this->decodeMessage($submessage, $data); + } else { + $value = $this->decodeSimpleType($reader, $type, $wire); + } + + // Support non-packed repeated fields + if ($field->isRepeated()) { + $message->_add($tag, $value); + } else { + $message->_set($tag, $value); + } + } + } + + return $message; + } + + protected function isPackable($type) + { + static $packable = array( + Protobuf::TYPE_INT64, + Protobuf::TYPE_UINT64, + Protobuf::TYPE_INT32, + Protobuf::TYPE_UINT32, + Protobuf::TYPE_SINT32, + Protobuf::TYPE_SINT64, + Protobuf::TYPE_DOUBLE, + Protobuf::TYPE_FIXED64, + Protobuf::TYPE_SFIXED64, + Protobuf::TYPE_FLOAT, + Protobuf::TYPE_FIXED32, + Protobuf::TYPE_SFIXED32, + Protobuf::TYPE_BOOL, + Protobuf::TYPE_ENUM + ); + + return in_array($type, $packable); + } + + protected function decodeUnknown($reader, $wire) + { + switch ($wire) { + case self::WIRE_VARINT: + return $reader->varint(); + case self::WIRE_LENGTH: + $length = $reader->varint(); + return $reader->read($length); + case self::WIRE_FIXED32: + return $reader->fixed32(); + case self::WIRE_FIXED64: + return $reader->fixed64(); + case self::WIRE_GROUP_START: + case self::WIRE_GROUP_END: + throw new \RuntimeException('Groups are deprecated in Protocol Buffers and unsupported by this library'); + default: + throw new \RuntimeException('Unsupported wire type (' . $wire . ') while consuming unknown field'); + } + } + + protected function assertWireType($wire, $type) + { + $expected = $this->getWireType($type, $wire); + if ($wire !== $expected) { + throw new \RuntimeException("Expected wire type $expected but got $wire for type $type"); + } + } + + protected function getWireType($type, $default) + { + switch ($type) { + case Protobuf::TYPE_INT32: + case Protobuf::TYPE_INT64: + case Protobuf::TYPE_UINT32: + case Protobuf::TYPE_UINT64: + case Protobuf::TYPE_SINT32: + case Protobuf::TYPE_SINT64: + case Protobuf::TYPE_BOOL: + case Protobuf::TYPE_ENUM: + return self::WIRE_VARINT; + case Protobuf::TYPE_FIXED64: + case Protobuf::TYPE_SFIXED64: + case Protobuf::TYPE_DOUBLE: + return self::WIRE_FIXED64; + case Protobuf::TYPE_STRING: + case Protobuf::TYPE_BYTES: + case Protobuf::TYPE_MESSAGE: + return self::WIRE_LENGTH; + case Protobuf::TYPE_FIXED32: + case Protobuf::TYPE_SFIXED32: + case Protobuf::TYPE_FLOAT: + return self::WIRE_FIXED32; + default: + // Unknown fields just return the reported wire type + return $default; + } + } + + protected function decodeSimpleType($reader, $type, $wireType) + { + switch ($type) { + case Protobuf::TYPE_INT64: + case Protobuf::TYPE_UINT64: + case Protobuf::TYPE_INT32: + case Protobuf::TYPE_UINT32: + return $reader->varint(); + + case Protobuf::TYPE_SINT32: // ZigZag + return $reader->zigzag(); + case Protobuf::TYPE_SINT64: // ZigZag + return $reader->zigzag(); + case Protobuf::TYPE_DOUBLE: + return $reader->double(); + case Protobuf::TYPE_FIXED64: + return $reader->fixed64(); + case Protobuf::TYPE_SFIXED64: + return $reader->sFixed64(); + + case Protobuf::TYPE_FLOAT: + return $reader->float(); + case Protobuf::TYPE_FIXED32: + return $reader->fixed32(); + case Protobuf::TYPE_SFIXED32: + return $reader->sFixed32(); + + case Protobuf::TYPE_BOOL: + return (bool)$reader->varint(); + + case Protobuf::TYPE_STRING: + $length = $reader->varint(); + return $reader->read($length); + + case Protobuf::TYPE_MESSAGE: + // Messages are not supported in this method + return null; + + case Protobuf::TYPE_BYTES: + $length = $reader->varint(); + return $reader->read($length); + + case Protobuf::TYPE_ENUM: + return $reader->varint(); + + default: + // Unknown type, follow wire type rules + switch ($wireType) { + case self::WIRE_VARINT: + return $reader->varint(); + case self::WIRE_FIXED32: + return $reader->fixed32(); + case self::WIRE_FIXED64: + return $reader->fixed64(); + case self::WIRE_LENGTH: + $length = $reader->varint(); + return $reader->read($length); + case self::WIRE_GROUP_START: + case self::WIRE_GROUP_END: + throw new \RuntimeException('Group is deprecated and not supported'); + default: + throw new \RuntimeException('Unsupported wire type number ' . $wireType); + } + } + + } + +}