php/sdk/google/appengine/runtime/proto/Decoder.php

<?php
/**
 * Copyright 2007 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
namespace google\net;

require_once 'google/appengine/runtime/proto/ProtocolBufferDecodeError.php';

/**
 * Class to decode protocol buffer from serialized form. Used by protocol
 * buffer implementation.
 */
class Decoder {
  const NUMERIC     = 0;
  const DOUBLE      = 1;
  const STRING      = 2;
  const STARTGROUP  = 3;
  const ENDGROUP    = 4;
  const FLOAT       = 5;
  const MAX_TYPE    = 6;

  const MAX_SHIFT = "1180591620717411303424";  // bcpow(128, 10)
  const MAX_INT64 = "9223372036854775807";     // bcsub(bcpow(2, 63), 1)
  const MIN_INT64 = "-9223372036854775808";    // bcsub(0, bcpow(2, 63))
  const MAX_INT32 = "2147483647";              // bcsub(bcpow(2, 31), 1)
  const MIN_INT32 = "-2147483648";             // bcsub(0,bcpow(2, 31))
  const RANGE_UINT64 = "18446744073709551616"; // bcpow(2, 64)
  const RANGE_UINT32 = "4294967296";           // bcpow(2, 32)

  private $buf;
  private $idx;
  private $limit;

  public function __construct($buf, $idx, $limit) {
    $this->buf = $buf;
    $this->idx = $idx;
    $this->limit = $limit;
  }

  public function avail() {
    return $this->limit - $this->idx;
  }

  public function buffer() {
    return $this->buf;
  }

  public function pos() {
    return $this->idx;
  }

  public function skip($n) {
    if ($this->idx + $n > $this->limit) {
      throw new ProtocolBufferDecodeError("truncated");
    }
    $this->idx += $n;
  }

  public function skipData($tag) {
    $t = $tag & 7;  // tag format type
    if ($t == Decoder::NUMERIC) {
      # TODO: use faster version of getVarInt64 which doesn't return
      # value skipVarInt64?
      $this->getVarInt64();
    } elseif ($t == Decoder::DOUBLE) {
      $this->skip(8);
    } elseif ($t == Decoder::STRING) {
      $n = $this->getVarInt32();
      if ($n < 0) {
        throw new ProtocolBufferDecodeError("corrupted");
      }
      $this->skip($n);
    } elseif ($t == Decoder::STARTGROUP) {
      while (1) {
        $t = $this->getVarInt32();
        if (($t & 7) == Decoder::ENDGROUP) {
          break;
        } else {
          $this->skipData($t);
        }
      }
      if (($t - Decoder::ENDGROUP) != ($tag - Decoder::STARTGROUP)) {
        throw new ProtocolBufferDecodeError("corrupted");
      }
    } elseif ($t == Decoder::ENDGROUP) {
      throw new ProtocolBufferDecodeError("corrupted");
    } elseif ($t == Decoder::FLOAT) {
      $this->skip(4);
    } else {
      throw new ProtocolBufferDecodeError("corrupted");
    }
  }

  // these are all unsigned gets
  public function get8() {
    if ($this->idx >= $this->limit) {
      throw new ProtocolBufferDecodeError("truncated");
    }
    $c = unpack("C*", substr($this->buf, $this->idx, 1));
    $this->idx += 1;
    return $c[1];
  }

  public function getVarUint32() {
    $b = $this->get8();
    if (($b & 128) == 0) {
      return $b;
    }

    $result = $b & 127;
    $mul = 128;

    // Loop for values within sint32 range:
    for ($i = 1; $i < 4; $i++) {
      $b = $this->get8();
      $result += $mul * ($b & 127);

      if (($b & 128) == 0) {
        return $result;
      }
      $mul *= 128;
    }

    // Handing uint32 which may be outside of sint32 range:
    $b = $this->get8();

    if (($b & 128) != 0) {
      throw new ProtocolBufferDecodeError("corrupted");
    }

    $result = bcadd($result, bcmul($b & 127, $mul));

    if (bccomp($result, Decoder::MAX_INT32) <= 0) {
      return intval($result);
    }

    if (bccomp($result, Decoder::RANGE_UINT32) >= 0) {
      throw new ProtocolBufferDecodeError("corrupted");
    }

    return $result;
  }

  public function getVarInt32() {
    $b = $this->get8();
    if (($b & 128) == 0) {
      return $b;
    }

    $result = $b & 127;
    $mul = 128;

    // Loop for values within sint32 range:
    for ($i = 1; $i < 4; $i++) {
      $b = $this->get8();
      $result += $mul * ($b & 127);

      if (($b & 128) == 0) {
        return $result;
      }
      $mul *= 128;
    }

    // Switch to big integer math outside of sint32 range:
    while (1) {
      $b = $this->get8();
      $result = bcadd($result, bcmul($b & 127, $mul));
      $mul = bcmul($mul, 128);

      if (($b & 128) == 0) {
        if (bccomp($result, Decoder::RANGE_UINT64) >= 0) {
          throw new ProtocolBufferDecodeError("corrupted");
        }
        break;
      }
      if (bccomp($mul, Decoder::MAX_SHIFT) > 0) {
        throw new ProtocolBufferDecodeError("corrupted");
      }
    }

    if (bccomp($result, Decoder::MAX_INT64) > 0) {
      $result = bcsub($result, Decoder::RANGE_UINT64);
    }
    if (bccomp($result, Decoder::MAX_INT32) > 0
      || bccomp($result, Decoder::MIN_INT32) < 0) {
      throw new ProtocolBufferDecodeError("corrupted");
    }
    return intval($result);
  }

  public function getVarInt64() {
    $result = $this->getVarUint64();
    if (bccomp($result, Decoder::MAX_INT64) > 0) {
      $result = bcsub($result, Decoder::RANGE_UINT64);
    }
    return $result;
  }

  public function getVarUint64() {
    $result = 0;
    $mul = 1;

    while (1) {
      if (bccomp($mul, Decoder::MAX_SHIFT) > 0) {
        throw new ProtocolBufferDecodeError("corrupted");
      }
      $b = $this->get8();
      $result = bcadd($result, bcmul($b & 127, $mul));
      $mul = bcmul($mul, 128);

      if (($b & 128) == 0) {
        if (bccomp($result, Decoder::RANGE_UINT64) >= 0) {
          throw new ProtocolBufferDecodeError("corrupted");
        }
        return $result;
      }
    }
  }

  public function getBoolean() {
    $b = $this->get8();
    if ($b != 0 && $b != 1) {
      throw new ProtocolBufferDecodeError("corrupted");
    }
    return $b == 1;
  }

  public function getFloat() {
    if ($this->idx + 4 > $this->limit) {
      throw new ProtocolBufferDecodeError("truncated");
    }
    $sub = substr($this->buf, $this->idx, 4);
    $this->idx += 4;
    $res = unpack('f1', $sub);
    return $res[1];
  }

  public function getDouble() {
    if ($this->idx + 8 > $this->limit) {
      throw new ProtocolBufferDecodeError("truncated");
    }
    $sub = substr($this->buf, $this->idx, 8);
    $this->idx += 8;
    $res = unpack('d1', $sub);
    return $res[1];
  }

  public function getFixed32() {
    if ($this->idx + 4 > $this->limit) {
      throw new ProtocolBufferDecodeError("truncated");
    }
    $sub = substr($this->buf, $this->idx, 4);
    $this->idx += 4;
    $res = unpack('V1', $sub);
    $val = $res[1];

    if ($val < 0) {
      $val = bcadd(Decoder::RANGE_UINT32, $val);
    }
    return $val;
  }

  public function getFixed64() {
    $l = $this->getFixed32();
    $h = $this->getFixed32();
    $res = bcadd(bcmul($h, Decoder::RANGE_UINT32), $l);
    return $res;
  }
}