Fix size 65536 HybiFrame (#24)

* fix size 65536 HybiFrame + nitpicks

off-by-1: previously, hybiframes with a 65536 bytes payload
would generate a 16 bit size header signaling 0 bytes (pack("n", 65536) => "\x00\x00"),
instead of using a 64bit size header.

nit: composer.json php version had not been updated since 8.0.2

nit: instead of is_int && in_array, we can use in_array's strict mode.

nit: $this->offset_mask and $this->offset_payload were
initialized-to-null in constructor and encode, then written internally in getPayloadOffset,
 then written in encode() again.

nit: use pack('J') instead of manually constructing big_endian_u64 (undocumented funfact, J is not available in 32bit php: php/doc-en#4644 ,
that may be why the original code did not use J)

nit: use random_bytes instead of openssl_random_pseudo_bytes(),
the original code was written for php5 where random_bytes did not exist.

nit: getInitialLength() was calculating the result twice internally.

* StyleCI

* PR feedback

https://github.com/chrome-php/wrench/pull/24/files#r2070000317
and
https://github.com/chrome-php/wrench/pull/24/files#r2069999223

Author: divinity76

src/Frame/HybiFrame.php

@@ -69,58 +69,60 @@ class HybiFrame extends Frame
      */
     public function encode(string $payload, int $type = Protocol::TYPE_TEXT, bool $masked = false): Frame
     {
-        if (!\is_int($type) || !\in_array($type, Protocol::FRAME_TYPES)) {
+        if (!\in_array($type, Protocol::FRAME_TYPES, true)) {
             throw new InvalidArgumentException('Invalid frame type');
         }
 
         $this->type = $type;
         $this->masked = $masked;
         $this->payload = $payload;
         $this->length = \strlen($this->payload);
-        $this->offset_mask = null;
-        $this->offset_payload = null;
 
         $this->buffer = "\x00\x00";
 
+        // FIN + opcode byte
         $this->buffer[self::BYTE_HEADER] = \chr(
             (self::BITFIELD_TYPE & $this->type)
-            | (self::BITFIELD_FINAL & \PHP_INT_MAX)
+                | self::BITFIELD_FINAL
         );
 
-        $masked_bit = (self::BITFIELD_MASKED & ($this->masked ? \PHP_INT_MAX : 0));
+        $masked_bit = $this->masked ? self::BITFIELD_MASKED : 0;
 
         if ($this->length <= 125) {
             $this->buffer[self::BYTE_INITIAL_LENGTH] = \chr(
-                (self::BITFIELD_INITIAL_LENGTH & $this->length) | $masked_bit
+                ($this->length & self::BITFIELD_INITIAL_LENGTH)
+                    | $masked_bit
             );
-        } elseif ($this->length <= 65536) {
+        } elseif ($this->length <= 65535) {
             $this->buffer[self::BYTE_INITIAL_LENGTH] = \chr(
-                (self::BITFIELD_INITIAL_LENGTH & 126) | $masked_bit
+                (126 & self::BITFIELD_INITIAL_LENGTH)
+                    | $masked_bit
             );
             $this->buffer .= \pack('n', $this->length);
         } else {
             $this->buffer[self::BYTE_INITIAL_LENGTH] = \chr(
-                (self::BITFIELD_INITIAL_LENGTH & 127) | $masked_bit
+                (127 & self::BITFIELD_INITIAL_LENGTH)
+                    | $masked_bit
             );
-
-            if (\PHP_INT_MAX > 2147483647) {
-                $this->buffer .= \pack('NN', $this->length >> 32, $this->length);
-            } else {
+            if (\PHP_INT_SIZE === 4) {
+                // J is not available on 32-bit PHP
                 $this->buffer .= \pack('NN', 0, $this->length);
+            } else {
+                $this->buffer .= \pack('J', $this->length);
             }
         }
 
         if ($this->masked) {
             $this->mask = $this->generateMask();
+            $this->offset_mask = \strlen($this->buffer);
             $this->buffer .= $this->mask;
+            $this->offset_payload = \strlen($this->buffer);
             $this->buffer .= $this->mask($this->payload);
         } else {
+            $this->offset_payload = \strlen($this->buffer);
             $this->buffer .= $this->payload;
         }
 
-        $this->offset_mask = $this->getMaskOffset();
-        $this->offset_payload = $this->getPayloadOffset();
-
         return $this;
     }
 
@@ -196,7 +198,6 @@ protected function getMaskOffset(): int
         if (!isset($this->offset_mask)) {
             $offset = self::BYTE_INITIAL_LENGTH + 1;
             $offset += $this->getLengthSize();
-
             $this->offset_mask = $offset;
         }
 
@@ -233,7 +234,6 @@ protected function getInitialLength(): int
         if (!isset($this->buffer[self::BYTE_INITIAL_LENGTH])) {
             throw new FrameException('Cannot yet tell expected length');
         }
-        $a = (int) (\ord($this->buffer[self::BYTE_INITIAL_LENGTH]) & self::BITFIELD_INITIAL_LENGTH);
 
         return (int) (\ord($this->buffer[self::BYTE_INITIAL_LENGTH]) & self::BITFIELD_INITIAL_LENGTH);
     }
@@ -258,7 +258,6 @@ protected function getPayloadOffset(): int
         if (!isset($this->offset_payload)) {
             $offset = $this->getMaskOffset();
             $offset += $this->getMaskSize();
-
             $this->offset_payload = $offset;
         }
 
@@ -294,7 +293,7 @@ public function getType(): int
 
         $type = (int) (\ord($this->buffer[self::BYTE_HEADER]) & self::BITFIELD_TYPE);
 
-        if (!\in_array($type, Protocol::FRAME_TYPES)) {
+        if (!\in_array($type, Protocol::FRAME_TYPES, true)) {
             throw new FrameException('Invalid payload type');
         }