純PHP實現的websocket客戶端

websocket協議RFC文檔地址：https://tools.ietf.org/html/rfc6455，以下是用純PHP實現的一個輕量的websocket客戶端，可以用來與websocket服務器進行通信。

 

<?php

namespace library\util;

use Exception;

class BadUriException extends Exception{}
class ServerConnectException extends Exception{}
class HandshakeException extends Exception{}
class BadFrameException extends Exception{}
class SocketRWException extends Exception{}

class WebSocketClient
{
    const PROTOCOL_WS = 'ws';
    const PROTOCOL_WSS = 'wss';

    const HTTP_HEADER_SEPARATION_MARK = "\r\n";
    const HTTP_HEADER_END_MARK = "\r\n\r\n";

    const UUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11';

    const PACKET_SIZE = (1 << 15);

    // 還有後續幀
    const OPCODE_CONTINUATION_FRAME = 0;
    // 文本幀
    const OPCODE_TEXT_FRAME = 1;
    // 二進制幀
    const OPCODE_BINARY_FRAME = 2;
    // 關閉連接
    const OPCODE_CLOSE = 8;
    // ping
    const OPCODE_PING = 9;
    // pong
    const OPCODE_PONG = 10;

    const FRAME_LENGTH_LEVEL_1_MAX = 125;
    const FRAME_LENGTH_LEVEL_2_MAX = 65535;

    private $protocol;

    private $host;

    private $port;

    private $path;

    private $sock;

    private $secWebSocketKey;

    private $handshakePass = false;

    private $readBuf;

    private $currentReadBufLen;

    private $readBufPos;

    private $closed = false;

    /**
     * WebSocketClient constructor.
     * @param $wsUri
     * @throws Exception
     */
    public function __construct($wsUri)
    {
        $this->parseUri($wsUri);

        $this->connect(10);

        $this->handshake();

        $this->initReadBuf();
    }

    /**
     * 解析websocket連接地址
     * @param $wsUri
     * @throws BadUriException
     */
    protected function parseUri($wsUri)
    {
        $uriData = parse_url($wsUri);
        if (!$uriData) {
            throw new BadUriException('不正確的ws uri格式', __LINE__);
        }
        if ($uriData['scheme'] != self::PROTOCOL_WS && $uriData['scheme'] != self::PROTOCOL_WSS) {
            throw new BadUriException('ws的uri必須是以ws://或wss://開頭', __LINE__);
        }
        $this->protocol = $uriData['scheme'];
        $this->host = $uriData['host'];

        if ($uriData['port']) {
            $this->port = (int)$uriData['port'];
        } else {
            if ($this->protocol == self::PROTOCOL_WSS) {
                $this->port = 443;
            } else {
                $this->port = 80;
            }
        }
        $this->path = $uriData['path'] ?: '/';
        if ($uriData['query']) {
            $this->path .= '?' . $uriData['query'];
        }
        if ($uriData['fragment']) {
            $this->path .= '#' . $uriData['fragment'];
        }
    }

    /**
     * 連接websocket服務器
     * @param $timeout
     * @throws ServerConnectException
     */
    protected function connect($timeout)
    {
        $this->sock = stream_socket_client(
            ($this->protocol == self::PROTOCOL_WSS ? 'ssl://' : 'tcp://') . $this->host . ':' . $this->port,
            $errno,
            $errstr,
            $timeout
        );

        if (!$this->sock) {

            if ($errstr) {
                throw new ServerConnectException('連接ws服務器失敗：' . $errstr, $errno);
            }

            throw new ServerConnectException('連接ws服務器失敗: 未知錯誤', __LINE__);
        }

        $this->setSockTimeout(30);
    }

    /**
     * 設置socket的讀寫超時時間
     * @param $seconds
     */
    public function setSockTimeout($seconds)
    {
        stream_set_timeout($this->sock, $seconds);
    }

    /**
     * @param $data
     * @throws SocketRWException
     */
    protected function writeToSock($data)
    {
        if ($this->closed) {
            throw new SocketRWException('連接已關閉, 不允許再發送消息', __LINE__);
        }

        $dataLen = strlen($data);
        if ($dataLen > self::PACKET_SIZE) {
            $dataPieces = str_split($data, self::PACKET_SIZE);
            foreach ($dataPieces as $piece) {
                $this->writeN($piece);
            }
        } else {
            $this->writeN($data);
        }
    }

    /**
     * 向socket寫入N個字節
     * @param $str
     * @throws SocketRWException
     */
    protected function writeN($str)
    {
        if ($this->closed) {
            throw new SocketRWException('連接已關閉, 不允許再發送消息', __LINE__);
        }

        $len = strlen($str);
        $writeLen = 0;
        do {
            if ($writeLen > 0) {
                $str = substr($str, $writeLen);
            }
            $n = fwrite($this->sock, $str);
            if ($n === false) {
                $meta = stream_get_meta_data($this->sock);
                if ($meta['timed_out']) {
                    throw new SocketRWException('向服務器發送數據超時', __LINE__);
                }
                throw new SocketRWException('無法發送數據，socket連接已斷開？', __LINE__);
            }
            $writeLen += $n;
        } while ($writeLen < $len);
    }

    /**
     * 隨機產生一個 Sec-WebSocket-Key
     * @return false|string
     */
    protected static function generateWsKey()
    {
        return base64_encode(md5(uniqid() . mt_rand(1, 8192), true));
    }

    /**
     * websocket握手
     * @throws Exception
     */
    protected function handshake()
    {
        $this->secWebSocketKey = self::generateWsKey();
        $headers = [
            'GET ' . $this->path . ' HTTP/1.1',
            'Host: ' . $this->host . ':' . $this->port,
            'Upgrade: websocket',
            'Connection: Upgrade',
            'Sec-WebSocket-Key: ' . $this->secWebSocketKey,
            'Sec-WebSocket-Version: 13',
        ];
        $htmlHeader = implode(self::HTTP_HEADER_SEPARATION_MARK, $headers) . self::HTTP_HEADER_END_MARK;
        $this->writeToSock($htmlHeader);
        $response = '';
        do {
            $response .= fread($this->sock, 8192);
            $end = strpos($response, self::HTTP_HEADER_END_MARK);
        } while ($end === false);

        if ($end === false) {
            throw new HandshakeException('握手失敗：握手響應不是標準的http響應', __LINE__);
        }

        $resHeader = substr($response, 0, $end);
        $headers = explode(self::HTTP_HEADER_SEPARATION_MARK, $resHeader);

        if (strpos($headers[0], '101') === false) {
            throw new HandshakeException('握手失敗：服務器返回http狀態碼不是101', __LINE__);
        }
        for($i = 1; $i < count($headers); $i++) {
            list($key, $val) = explode(':', $headers[$i]);
            if (strtolower(trim($key)) == 'sec-websocket-accept') {
                $accept = base64_encode(sha1($this->secWebSocketKey . self::UUID, true));
                if (trim($val) != $accept) {
                    throw new HandshakeException('握手失敗： sec-websocket-accept值校驗失敗', __LINE__);
                }
                $this->handshakePass = true;
                break;
            }
        }
        if (!$this->handshakePass) {
            throw new HandshakeException('握手失敗：缺少sec-websocket-accept http頭', __LINE__);
        }
    }

    /**
     * @param int $opCode 幀類型
     * @param string $playLoad 攜帶的數據
     * @param bool $isMask 是否使用掩碼
     * @param int $status 關閉幀狀態
     * @return false|string
     */
    protected function packFrame($opCode, $playLoad = '', $isMask = true, $status = 1000)
    {
        $firstByte = 0x80 | $opCode;
        if ($isMask) {
            $secondByte = 0x80;
        } else {
            $secondByte = 0x00;
        }

        $playLoadLen = strlen($playLoad);
        if ($opCode == self::OPCODE_CLOSE) {
            // 協議規定關閉幀必須使用掩碼
            $isMask = true;
            $playLoad = pack('CC', (($status >> 8) & 0xff), $status & 0xff) . $playLoad;
            $playLoadLen += 2;
        }
        if ($playLoadLen <= self::FRAME_LENGTH_LEVEL_1_MAX) {
            $secondByte |= $playLoadLen;
            $frame = pack('CC', $firstByte, $secondByte);
        } elseif ($playLoadLen <= self::FRAME_LENGTH_LEVEL_2_MAX) {
            $secondByte |= 126;
            $frame = pack('CCn', $firstByte, $secondByte, $playLoadLen);
        } else {
            $secondByte |= 127;
            $frame = pack('CCJ', $firstByte, $secondByte, $playLoadLen);
        }

        if ($isMask) {
            $maskBytes = [mt_rand(1, 255), mt_rand(1, 255), mt_rand(1, 255), mt_rand(1, 255)];
            $frame .= pack('CCCC', $maskBytes[0], $maskBytes[1], $maskBytes[2], $maskBytes[3]);
            if ($playLoadLen > 0) {
                for ($i = 0; $i < $playLoadLen; $i++) {
                    $playLoad{$i} = chr(ord($playLoad{$i}) ^ $maskBytes[$i % 4]);
                }
            }
        }

        $frame .= $playLoad;

        return $frame;
    }

    /**
     * ping服務器
     * @throws Exception
     */
    public function ping()
    {
        $frame = $this->packFrame(self::OPCODE_PING, '', true);
        $this->writeToSock($frame);
        $pong = $this->recv();
        if ($pong->opcode == self::OPCODE_PONG) {
            return true;
        }
        return false;
    }

    /**
     * 響應服務器的ping
     * @throws Exception
     */
    public function pong()
    {
        $frame = $this->packFrame(self::OPCODE_PONG, '', true);
        $this->writeToSock($frame);
    }

    /**
     * 主動關閉與服務器的連接
     * @throws Exception
     * @return bool
     */
    public function close()
    {
        $frame = $this->packFrame(self::OPCODE_CLOSE, '', true, 1000);
        $this->writeToSock($frame);

        // 主動關閉需要再接收一次對端返回的確認消息
        $wsData = $this->recv();
        if ($wsData->opcode == self::OPCODE_CLOSE) {
            $this->closed = true;
            stream_socket_shutdown($this->sock, STREAM_SHUT_RDWR);
            return true;
        }
        return false;
    }

    /**
     * 響應服務器的關閉消息
     * @throws SocketRWException
     */
    protected function closureRespond()
    {
        $frame = $this->packFrame(self::OPCODE_CLOSE, '', true, 1000);
        $this->writeToSock($frame);
        $this->closed = true;
        stream_socket_shutdown($this->sock, STREAM_SHUT_RDWR);
    }

    /**
     * @param string $data 要發送的數據
     * @param int $opCode 發送的數據類型 WebSocketClient::OPCODE_TEXT_FRAME 或 WebSocketClient::OPCODE_BINARY_FRAME
     * @param bool $isMask 是否使用掩碼，默認使用
     * @throws Exception
     */
    public function send($data, $opCode = self::OPCODE_TEXT_FRAME, $isMask = true)
    {
        if ($opCode != self::OPCODE_TEXT_FRAME && $opCode != self::OPCODE_BINARY_FRAME) {
            throw new \InvalidArgumentException('不支持的幀數據類型', __LINE__);
        }

        $frame = $this->packFrame($opCode, $data, $isMask);

        $this->writeToSock($frame);
    }

    /**
     * 初始化收取數據緩衝區
     */
    private function initReadBuf()
    {
        $this->readBuf = '';
        $this->currentReadBufLen = 0;
        $this->readBufPos = 0;
    }

    /**
     * 從讀取緩衝區中當前位置返回指定長度字符串
     * @param int $len 返回長度
     * @return bool|string
     * @throws SocketRWException
     */
    private function fetchStrFromReadBuf($len = 1)
    {
        $target = $this->readBufPos + $len;

        while ($target > $this->currentReadBufLen) {
            if ($this->closed) {
                throw new SocketRWException('連接已關閉, 不允許再收取消息', __LINE__);
            }
            $read = fread($this->sock, self::PACKET_SIZE);
            if (!$read) {
                $meta = stream_get_meta_data($this->sock);
                if ($meta['timed_out']) {
                    throw new SocketRWException('讀取服務器數據超時', __LINE__);
                }
                throw new SocketRWException('無法讀取服務器數據，錯誤未知', __LINE__);
            }
            $this->readBuf .= $read;
            $this->currentReadBufLen += strlen($read);
        }
        $str = substr($this->readBuf, $this->readBufPos, $len);
        $this->readBufPos += $len;
        return $str;
    }

    /**
     * 返回讀取緩衝區當前位置字符的ascii碼
     * @return int
     * @throws SocketRWException
     */
    private function fetchCharFromReadBuf()
    {
        $str = $this->FetchStrFromReadBuf(1);
        return ord($str{0});
    }

    /**
     * 丟棄讀取緩衝區已處理的指定長度數據
     * @param $len
     */
    private function discardReadBuf($len)
    {
        // 未處理的數據不會被丟棄
        if ($len > $this->readBufPos) {
            $len = $this->readBufPos;
        }
        if ($len > 0) {
            $this->readBuf = substr($this->readBuf, $len);
            $this->readBufPos -= $len;
            $this->currentReadBufLen -= $len;
        }
    }

    /**
     * @return WsDataFrame
     * @throws Exception
     */
    public function recv()
    {
        $dataFrame = $this->readFrame();
        switch ($dataFrame->opcode) {

            case self::OPCODE_PING:
                $this->pong();
                break;

            case self::OPCODE_PONG:
                break;

            case self::OPCODE_TEXT_FRAME:
            case self::OPCODE_BINARY_FRAME:
            case self::OPCODE_CLOSE:
                if ($dataFrame->fin == 0) {
                    do {
                        $continueFrame = $this->readFrame();
                        $dataFrame->playload .= $continueFrame->playload;
                    } while ($continueFrame->fin == 0);
                }

                if ($dataFrame->opcode == self::OPCODE_CLOSE) {
                    $this->closureRespond();
                }
                break;
            default:
                throw new BadFrameException('無法識別的frame數據', __LINE__);
                break;
        }
        return $dataFrame;
    }

    /**
     * 讀取一個數據幀
     * @return WsDataFrame
     * @throws SocketRWException
     */
    protected function readFrame()
    {
        $firstByte = $this->fetchCharFromReadBuf();
        $fin = ($firstByte >> 7);
        $opcode = $firstByte & 0x0F;
        $secondByte = $this->fetchCharFromReadBuf();
        $isMasked = ($secondByte >> 7);
        $dataLen = $secondByte & 0x7F;
        if ($dataLen == 126) {
            // 2字節無符號整形
            $dataLen = ($this->fetchCharFromReadBuf() << 8) + $this->fetchCharFromReadBuf();
        } elseif ($dataLen == 127) {
            // 8字節無符號整形
            $dataLen = $this->fetchStrFromReadBuf(8);
            $res = unpack('Jlen', $dataLen);
            if (isset($res['len'])) {
                $dataLen = $res['len'];
            } else {
                $dataLen = (ord($dataLen{0}) << 56)
                    + (ord($dataLen{1}) << 48)
                    + (ord($dataLen{2}) << 40)
                    + (ord($dataLen{3}) << 32)
                    + (ord($dataLen{4}) << 24)
                    + (ord($dataLen{5}) << 16)
                    + (ord($dataLen{6}) << 8)
                    + ord($dataLen{7});
            }
        }

        $data = '';
        $status = 0;
        if ($dataLen > 0) {
            if ($isMasked) {
                // 4字節掩碼
                $maskChars = $this->fetchStrFromReadBuf(4);
                $maskSet = [ord($maskChars{0}), ord($maskChars{1}), ord($maskChars{2}), ord($maskChars{3})];
                $data = $this->fetchStrFromReadBuf($dataLen);
                for($i = 0; $i < $dataLen; $i++) {
                    $data{$i} = chr(ord($data{$i}) ^ $maskSet[$i % 4]);
                }
            } else {
                $data = $this->fetchStrFromReadBuf($dataLen);
            }
            if ($opcode == self::OPCODE_CLOSE) {
                $status = (ord($data[0]) << 8) + ord($data[1]);
                $data = substr($data, 2);
            }
        }

        $this->discardReadBuf($this->readBufPos);

        $dataFrame = new WsDataFrame();
        $dataFrame->opcode = $opcode;
        $dataFrame->fin = $fin;
        $dataFrame->status = $status;
        $dataFrame->playload = $data;
        return $dataFrame;
    }

    /**
     * __destruct
     */
    public function __destruct()
    {
        if (!$this->closed && $this->sock) {
            try {
                $this->close();
            } catch (\Throwable $e){}
        }
    }
}

/**
 * websocket數據幀
 * Class wsDataFrame
 * @package library\util
 */
class WsDataFrame
{
    /**
     * @var int $opcode
     */
    public $opcode;

    /**
     * @var int $fin 標識數據包是否已結束
     */
    public $fin;

    /**
     * @var int $status 關閉時的狀態碼，如果有的話
     */
    public $status;

    /**
     * @var string 數據包攜帶的數據
     */
    public $playload;
}

簡單使用示例：

<?php

try {

    $ws = new WebSocketClient('ws://127.0.0.1/chat');
    var_dump($ws->ping());
    var_dump($ws->send('hello ws!'));
    $frame = $ws->recv();
    echo "收到服務器響應數據：" . $frame->playload . PHP_EOL;
    var_dump($ws->close());

} catch (\Exception $e) {
    echo "錯誤: " . $e->getMessage();
    var_dump($e);
}