Code Coverage
 
Lines
Functions and Methods
Classes and Traits
Total
39.57% covered (danger)
39.57%
93 / 235
0.00% covered (danger)
0.00%
0 / 6
CRAP
0.00% covered (danger)
0.00%
0 / 1
Websocket
39.57% covered (danger)
39.57%
93 / 235
0.00% covered (danger)
0.00%
0 / 6
1282.16
0.00% covered (danger)
0.00%
0 / 1
 input
34.31% covered (danger)
34.31%
35 / 102
0.00% covered (danger)
0.00%
0 / 1
341.64
 encode
31.03% covered (danger)
31.03%
9 / 29
0.00% covered (danger)
0.00%
0 / 1
78.29
 decode
59.26% covered (warning)
59.26%
16 / 27
0.00% covered (danger)
0.00%
0 / 1
10.31
 inflate
0.00% covered (danger)
0.00%
0 / 13
0.00% covered (danger)
0.00%
0 / 1
12
 deflate
0.00% covered (danger)
0.00%
0 / 11
0.00% covered (danger)
0.00%
0 / 1
6
 dealHandshake
62.26% covered (warning)
62.26%
33 / 53
0.00% covered (danger)
0.00%
0 / 1
27.09
1<?php
2/**
3 * This file is part of workerman.
4 *
5 * Licensed under The MIT License
6 * For full copyright and license information, please see the MIT-LICENSE.txt
7 * Redistributions of files must retain the above copyright notice.
8 *
9 * @author    walkor<walkor@workerman.net>
10 * @copyright walkor<walkor@workerman.net>
11 * @link      http://www.workerman.net/
12 * @license   http://www.opensource.org/licenses/mit-license.php MIT License
13 */
14
15declare(strict_types=1);
16
17namespace Workerman\Protocols;
18
19use Throwable;
20use Workerman\Connection\ConnectionInterface;
21use Workerman\Connection\TcpConnection;
22use Workerman\Protocols\Http\Request;
23use Workerman\Worker;
24use function base64_encode;
25use function chr;
26use function deflate_add;
27use function deflate_init;
28use function floor;
29use function inflate_add;
30use function inflate_init;
31use function is_scalar;
32use function ord;
33use function pack;
34use function preg_match;
35use function sha1;
36use function str_repeat;
37use function stripos;
38use function strlen;
39use function strpos;
40use function substr;
41use function unpack;
42use const ZLIB_DEFAULT_STRATEGY;
43use const ZLIB_ENCODING_RAW;
44
45/**
46 * WebSocket protocol.
47 */
48class Websocket
49{
50    /**
51     * Websocket blob type.
52     *
53     * @var string
54     */
55    public const BINARY_TYPE_BLOB = "\x81";
56
57    /**
58     * Websocket blob type.
59     *
60     * @var string
61     */
62    const BINARY_TYPE_BLOB_DEFLATE = "\xc1";
63
64    /**
65     * Websocket arraybuffer type.
66     *
67     * @var string
68     */
69    public const BINARY_TYPE_ARRAYBUFFER = "\x82";
70
71    /**
72     * Websocket arraybuffer type.
73     *
74     * @var string
75     */
76    const BINARY_TYPE_ARRAYBUFFER_DEFLATE = "\xc2";
77
78    /**
79     * Check the integrity of the package.
80     *
81     * @param string $buffer
82     * @param TcpConnection $connection
83     * @return int
84     */
85    public static function input(string $buffer, TcpConnection $connection): int
86    {
87        $connection->websocketOrigin = $connection->websocketOrigin ?? null;
88        $connection->websocketClientProtocol = $connection->websocketClientProtocol ?? null;
89        // Receive length.
90        $recvLen = strlen($buffer);
91        // We need more data.
92        if ($recvLen < 6) {
93            return 0;
94        }
95
96        // Has not yet completed the handshake.
97        if (empty($connection->context->websocketHandshake)) {
98            return static::dealHandshake($buffer, $connection);
99        }
100
101        // Buffer websocket frame data.
102        if ($connection->context->websocketCurrentFrameLength) {
103            // We need more frame data.
104            if ($connection->context->websocketCurrentFrameLength > $recvLen) {
105                // Return 0, because it is not clear the full packet length, waiting for the frame of fin=1.
106                return 0;
107            }
108        } else {
109            $firstByte = ord($buffer[0]);
110            $secondByte = ord($buffer[1]);
111            $dataLen = $secondByte & 127;
112            $isFinFrame = $firstByte >> 7;
113            $masked = $secondByte >> 7;
114
115            if (!$masked) {
116                Worker::safeEcho("frame not masked so close the connection\n");
117                $connection->close();
118                return 0;
119            }
120
121            $opcode = $firstByte & 0xf;
122            switch ($opcode) {
123                case 0x0:
124                    // Blob type.
125                case 0x1:
126                    // Arraybuffer type.
127                case 0x2:
128                    // Ping package.
129                case 0x9:
130                    // Pong package.
131                case 0xa:
132                    break;
133                // Close package.
134                case 0x8:
135                    // Try to emit onWebSocketClose callback.
136                    $closeCb = $connection->onWebSocketClose ?? $connection->worker->onWebSocketClose ?? false;
137                    if ($closeCb) {
138                        try {
139                            $closeCb($connection);
140                        } catch (Throwable $e) {
141                            Worker::stopAll(250, $e);
142                        }
143                    } // Close connection.
144                    else {
145                        $connection->close("\x88\x02\x03\xe8", true);
146                    }
147                    return 0;
148                // Wrong opcode.
149                default :
150                    Worker::safeEcho("error opcode $opcode and close websocket connection. Buffer:" . bin2hex($buffer) . "\n");
151                    $connection->close();
152                    return 0;
153            }
154
155            // Calculate packet length.
156            $headLen = 6;
157            if ($dataLen === 126) {
158                $headLen = 8;
159                if ($headLen > $recvLen) {
160                    return 0;
161                }
162                $pack = unpack('nn/ntotal_len', $buffer);
163                $dataLen = $pack['total_len'];
164            } else {
165                if ($dataLen === 127) {
166                    $headLen = 14;
167                    if ($headLen > $recvLen) {
168                        return 0;
169                    }
170                    $arr = unpack('n/N2c', $buffer);
171                    $dataLen = $arr['c1'] * 4294967296 + $arr['c2'];
172                }
173            }
174            $currentFrameLength = $headLen + $dataLen;
175
176            $totalPackageSize = strlen($connection->context->websocketDataBuffer) + $currentFrameLength;
177            if ($totalPackageSize > $connection->maxPackageSize) {
178                Worker::safeEcho("error package. package_length=$totalPackageSize\n");
179                $connection->close();
180                return 0;
181            }
182
183            if ($isFinFrame) {
184                if ($opcode === 0x9) {
185                    if ($recvLen >= $currentFrameLength) {
186                        $pingData = static::decode(substr($buffer, 0, $currentFrameLength), $connection);
187                        $connection->consumeRecvBuffer($currentFrameLength);
188                        $tmpConnectionType = $connection->websocketType ?? static::BINARY_TYPE_BLOB;
189                        $connection->websocketType = "\x8a";
190                        $pingCb = $connection->onWebSocketPing ?? $connection->worker->onWebSocketPing ?? false;
191                        if ($pingCb) {
192                            try {
193                                $pingCb($connection, $pingData);
194                            } catch (Throwable $e) {
195                                Worker::stopAll(250, $e);
196                            }
197                        } else {
198                            $connection->send($pingData);
199                        }
200                        $connection->websocketType = $tmpConnectionType;
201                        if ($recvLen > $currentFrameLength) {
202                            return static::input(substr($buffer, $currentFrameLength), $connection);
203                        }
204                    }
205                    return 0;
206                }
207
208                if ($opcode === 0xa) {
209                    if ($recvLen >= $currentFrameLength) {
210                        $pongData = static::decode(substr($buffer, 0, $currentFrameLength), $connection);
211                        $connection->consumeRecvBuffer($currentFrameLength);
212                        $tmpConnectionType = $connection->websocketType ?? static::BINARY_TYPE_BLOB;
213                        $connection->websocketType = "\x8a";
214                        // Try to emit onWebSocketPong callback.
215                        $pongCb = $connection->onWebSocketPong ?? $connection->worker->onWebSocketPong ?? false;
216                        if ($pongCb) {
217                            try {
218                                $pongCb($connection, $pongData);
219                            } catch (Throwable $e) {
220                                Worker::stopAll(250, $e);
221                            }
222                        }
223                        $connection->websocketType = $tmpConnectionType;
224                        if ($recvLen > $currentFrameLength) {
225                            return static::input(substr($buffer, $currentFrameLength), $connection);
226                        }
227                    }
228                    return 0;
229                }
230                return $currentFrameLength;
231            }
232
233            $connection->context->websocketCurrentFrameLength = $currentFrameLength;
234        }
235
236        // Received just a frame length data.
237        if ($connection->context->websocketCurrentFrameLength === $recvLen) {
238            static::decode($buffer, $connection);
239            $connection->consumeRecvBuffer($connection->context->websocketCurrentFrameLength);
240            $connection->context->websocketCurrentFrameLength = 0;
241            return 0;
242        }
243
244        // The length of the received data is greater than the length of a frame.
245        if ($connection->context->websocketCurrentFrameLength < $recvLen) {
246            static::decode(substr($buffer, 0, $connection->context->websocketCurrentFrameLength), $connection);
247            $connection->consumeRecvBuffer($connection->context->websocketCurrentFrameLength);
248            $currentFrameLength = $connection->context->websocketCurrentFrameLength;
249            $connection->context->websocketCurrentFrameLength = 0;
250            // Continue to read next frame.
251            return static::input(substr($buffer, $currentFrameLength), $connection);
252        }
253
254        // The length of the received data is less than the length of a frame.
255        return 0;
256    }
257
258    /**
259     * Websocket encode.
260     *
261     * @param mixed $buffer
262     * @param TcpConnection $connection
263     * @return string
264     */
265    public static function encode(mixed $buffer, TcpConnection $connection): string
266    {
267        if (!is_scalar($buffer)) {
268            $buffer = json_encode($buffer, JSON_UNESCAPED_UNICODE);
269        }
270
271        if (empty($connection->websocketType)) {
272            $connection->websocketType = static::BINARY_TYPE_BLOB;
273        }
274
275        if (ord($connection->websocketType) & 64) {
276            $buffer = static::deflate($connection, $buffer);
277        }
278
279        $firstByte = $connection->websocketType;
280        $len = strlen($buffer);
281
282        if ($len <= 125) {
283            $encodeBuffer = $firstByte . chr($len) . $buffer;
284        } else {
285            if ($len <= 65535) {
286                $encodeBuffer = $firstByte . chr(126) . pack("n", $len) . $buffer;
287            } else {
288                $encodeBuffer = $firstByte . chr(127) . pack("xxxxN", $len) . $buffer;
289            }
290        }
291
292        // Handshake not completed so temporary buffer websocket data waiting for send.
293        if (empty($connection->context->websocketHandshake)) {
294            if (empty($connection->context->tmpWebsocketData)) {
295                $connection->context->tmpWebsocketData = '';
296            }
297            // If buffer has already full then discard the current package.
298            if (strlen($connection->context->tmpWebsocketData) > $connection->maxSendBufferSize) {
299                if ($connection->onError) {
300                    try {
301                        ($connection->onError)($connection, ConnectionInterface::SEND_FAIL, 'send buffer full and drop package');
302                    } catch (Throwable $e) {
303                        Worker::stopAll(250, $e);
304                    }
305                }
306                return '';
307            }
308            $connection->context->tmpWebsocketData .= $encodeBuffer;
309            // Check buffer is full.
310            if ($connection->onBufferFull && $connection->maxSendBufferSize <= strlen($connection->context->tmpWebsocketData)) {
311                try {
312                    ($connection->onBufferFull)($connection);
313                } catch (Throwable $e) {
314                    Worker::stopAll(250, $e);
315                }
316            }
317            // Return empty string.
318            return '';
319        }
320
321        return $encodeBuffer;
322    }
323
324    /**
325     * Websocket decode.
326     *
327     * @param string $buffer
328     * @param TcpConnection $connection
329     * @return string
330     */
331    public static function decode(string $buffer, TcpConnection $connection): string
332    {
333        $firstByte = ord($buffer[0]);
334        $secondByte = ord($buffer[1]);
335        $len = $secondByte & 127;
336        $isFinFrame = (bool)($firstByte >> 7);
337        $rsv1 = 64 === ($firstByte & 64);
338
339        if ($len === 126) {
340            $masks = substr($buffer, 4, 4);
341            $data = substr($buffer, 8);
342        } else {
343            if ($len === 127) {
344                $masks = substr($buffer, 10, 4);
345                $data = substr($buffer, 14);
346            } else {
347                $masks = substr($buffer, 2, 4);
348                $data = substr($buffer, 6);
349            }
350        }
351        $dataLength = strlen($data);
352        $masks = str_repeat($masks, (int)floor($dataLength / 4)) . substr($masks, 0, $dataLength % 4);
353        $decoded = $data ^ $masks;
354        if ($connection->context->websocketCurrentFrameLength) {
355            $connection->context->websocketDataBuffer .= $decoded;
356            if ($rsv1) {
357                return static::inflate($connection, $connection->context->websocketDataBuffer, $isFinFrame);
358            }
359            return $connection->context->websocketDataBuffer;
360        }
361        if ($connection->context->websocketDataBuffer !== '') {
362            $decoded = $connection->context->websocketDataBuffer . $decoded;
363            $connection->context->websocketDataBuffer = '';
364        }
365        if ($rsv1) {
366            return static::inflate($connection, $decoded, $isFinFrame);
367        }
368        return $decoded;
369    }
370
371    /**
372     * Inflate.
373     *
374     * @param TcpConnection $connection
375     * @param string $buffer
376     * @param bool $isFinFrame
377     * @return false|string
378     */
379    protected static function inflate(TcpConnection $connection, string $buffer, bool $isFinFrame): bool|string
380    {
381        if (!isset($connection->context->inflator)) {
382            $connection->context->inflator = inflate_init(
383                ZLIB_ENCODING_RAW,
384                [
385                    'level'    => -1,
386                    'memory'   => 8,
387                    'window'   => 15,
388                    'strategy' => ZLIB_DEFAULT_STRATEGY
389                ]
390            );
391        }
392        if ($isFinFrame) {
393            $buffer .= "\x00\x00\xff\xff";
394        }
395        return inflate_add($connection->context->inflator, $buffer);
396    }
397
398    /**
399     * Deflate.
400     *
401     * @param TcpConnection $connection
402     * @param string $buffer
403     * @return false|string
404     */
405    protected static function deflate(TcpConnection $connection, string $buffer): bool|string
406    {
407        if (!isset($connection->context->deflator)) {
408            $connection->context->deflator = deflate_init(
409                ZLIB_ENCODING_RAW,
410                [
411                    'level'    => -1,
412                    'memory'   => 8,
413                    'window'   => 15,
414                    'strategy' => ZLIB_DEFAULT_STRATEGY
415                ]
416            );
417        }
418        return substr(deflate_add($connection->context->deflator, $buffer), 0, -4);
419    }
420
421    /**
422     * Websocket handshake.
423     *
424     * @param string $buffer
425     * @param TcpConnection $connection
426     * @return int
427     */
428    public static function dealHandshake(string $buffer, TcpConnection $connection): int
429    {
430        // HTTP protocol.
431        if (str_starts_with($buffer, 'GET')) {
432            // Find \r\n\r\n.
433            $headerEndPos = strpos($buffer, "\r\n\r\n");
434            if (!$headerEndPos) {
435                return 0;
436            }
437            $headerLength = $headerEndPos + 4;
438
439            // Get Sec-WebSocket-Key.
440            if (preg_match("/Sec-WebSocket-Key: *(.*?)\r\n/i", $buffer, $match)) {
441                $SecWebSocketKey = $match[1];
442            } else {
443                $connection->close(
444                    "HTTP/1.0 400 Bad Request\r\nServer: workerman\r\n\r\n<div style=\"text-align:center\"><h1>WebSocket</h1><hr>workerman</div>", true);
445                return 0;
446            }
447            // Calculation websocket key.
448            $newKey = base64_encode(sha1($SecWebSocketKey . "258EAFA5-E914-47DA-95CA-C5AB0DC85B11", true));
449            // Handshake response data.
450            $handshakeMessage = "HTTP/1.1 101 Switching Protocol\r\n"
451                . "Upgrade: websocket\r\n"
452                . "Sec-WebSocket-Version: 13\r\n"
453                . "Connection: Upgrade\r\n"
454                . "Sec-WebSocket-Accept: " . $newKey . "\r\n";
455
456            // Websocket data buffer.
457            $connection->context->websocketDataBuffer = '';
458            // Current websocket frame length.
459            $connection->context->websocketCurrentFrameLength = 0;
460            // Current websocket frame data.
461            $connection->context->websocketCurrentFrameBuffer = '';
462            // Consume handshake data.
463            $connection->consumeRecvBuffer($headerLength);
464            // Request from buffer
465            $request = new Request($buffer);
466
467            // Try to emit onWebSocketConnect callback.
468            $onWebsocketConnect = $connection->onWebSocketConnect ?? $connection->worker->onWebSocketConnect ?? false;
469            if ($onWebsocketConnect) {
470                try {
471                    $onWebsocketConnect($connection, $request);
472                } catch (Throwable $e) {
473                    Worker::stopAll(250, $e);
474                }
475            }
476
477            // blob or arraybuffer
478            if (empty($connection->websocketType)) {
479                $connection->websocketType = static::BINARY_TYPE_BLOB;
480            }
481
482            $hasServerHeader = false;
483
484            if ($connection->headers) {
485                foreach ($connection->headers as $header) {
486                    if (stripos($header, 'Server:') === 0) {
487                        $hasServerHeader = true;
488                    }
489                    $handshakeMessage .= "$header\r\n";
490                }
491            }
492            if (!$hasServerHeader) {
493                $handshakeMessage .= "Server: workerman\r\n";
494            }
495            $handshakeMessage .= "\r\n";
496            // Send handshake response.
497            $connection->send($handshakeMessage, true);
498            // Mark handshake complete.
499            $connection->context->websocketHandshake = true;
500
501            // Try to emit onWebSocketConnected callback.
502            $onWebsocketConnected = $connection->onWebSocketConnected ?? $connection->worker->onWebSocketConnected ?? false;
503            if ($onWebsocketConnected) {
504                try {
505                    $onWebsocketConnected($connection, $request);
506                } catch (Throwable $e) {
507                    Worker::stopAll(250, $e);
508                }
509            }
510
511            // There are data waiting to be sent.
512            if (!empty($connection->context->tmpWebsocketData)) {
513                $connection->send($connection->context->tmpWebsocketData, true);
514                $connection->context->tmpWebsocketData = '';
515            }
516            if (strlen($buffer) > $headerLength) {
517                return static::input(substr($buffer, $headerLength), $connection);
518            }
519            return 0;
520        }
521        // Bad websocket handshake request.
522        $connection->close(
523            "HTTP/1.0 400 Bad Request\r\nServer: workerman\r\n\r\n<div style=\"text-align:center\"><h1>400 Bad Request</h1><hr>workerman</div>", true);
524        return 0;
525    }
526}