初始上传

app/gateway/README.md

@@ -0,0 +1,46 @@
+GatewayWorker windows 版本
+=================
+
+GatewayWorker基于[Workerman](https://github.com/walkor/Workerman)开发的一个项目框架，用于快速开发长连接应用，例如app推送服务端、即时IM服务端、游戏服务端、物联网、智能家居等等。
+
+GatewayWorker使用经典的Gateway和Worker进程模型。Gateway进程负责维持客户端连接，并转发客户端的数据给Worker进程处理；Worker进程负责处理实际的业务逻辑，并将结果推送给对应的客户端。Gateway服务和Worker服务可以分开部署在不同的服务器上，实现分布式集群。
+
+GatewayWorker提供非常方便的API，可以全局广播数据、可以向某个群体广播数据、也可以向某个特定客户端推送数据。配合Workerman的定时器，也可以定时推送数据。
+
+GatewayWorker Linux 版本
+======================
+Linux 版本GatewayWorker 在这里 https://github.com/walkor/GatewayWorker
+
+启动
+=======
+双击start_for_win.bat
+
+Applications\YourApp测试方法
+======
+使用telnet命令测试（不要使用windows自带的telnet）
+```shell
+ telnet 127.0.0.1 8282
+Trying 127.0.0.1...
+Connected to 127.0.0.1.
+Escape character is '^]'.
+Hello 3
+3 login
+haha
+3 said haha
+```
+
+手册
+=======
+http://www.workerman.net/gatewaydoc/
+
+使用GatewayWorker-for-win开发的项目
+=======
+## [tadpole](http://kedou.workerman.net/)  
+[Live demo](http://kedou.workerman.net/)  
+[Source code](https://github.com/walkor/workerman)  
+![workerman-todpole](http://www.workerman.net/img/workerman-todpole.png)   
+
+## [chat room](http://chat.workerman.net/)  
+[Live demo](http://chat.workerman.net/)  
+[Source code](https://github.com/walkor/workerman-chat)  
+![workerman-chat](http://www.workerman.net/img/workerman-chat.png)  

app/gateway/composer.json

@@ -0,0 +1,10 @@
+{
+    "name"  : "workerman/gateway-worker-demo",
+    "keywords": ["distributed","communication"],
+    "homepage": "http://www.workerman.net",
+    "license" : "MIT",
+    "require": {
+        "workerman/gateway-worker" : ">=3.0.0",
+        "workerman/mysql": "^1.0"
+    }
+}

app/gateway/service/Events.php

@@ -0,0 +1,94 @@
+<?php
+
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @link http://www.workerman.net/
+ * @license http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+
+/**
+ * 用于检测业务代码死循环或者长时间阻塞等问题
+ * 如果发现业务卡死，可以将下面declare打开（去掉//注释），并执行php start.php reload
+ * 然后观察一段时间workerman.log看是否有process_timeout异常
+ */
+//declare(ticks=1);
+
+use \GatewayWorker\Lib\Gateway;
+use Workerman\MySQL\Connection;
+
+/**
+ * 主逻辑
+ * 主要是处理 onConnect onMessage onClose 三个方法
+ * onConnect 和 onClose 如果不需要可以不用实现并删除
+ */
+class Events
+{
+    protected static $db;
+    protected static $prefix;
+
+    /**
+     * 进行启动时操作
+     *
+     * @param mixed $businessWorker
+     * @return void
+     */
+    public static function onWorkerStart($businessWorker)
+    {
+        $config_info = require __DIR__ . '/../../../config/gateway.php';
+        $config = $config_info['database'];
+        self::$prefix = $config['prefix'];
+        self::$db = new Connection($config['host'], $config['port'], $config['user'], $config['passwd'], $config['dbname']);
+
+        // 全部下线
+        @self::$db->update(self::$prefix . 'servicer')->cols(['online' => 0, 'client_id' => ''])->query();
+        @self::$db->update(self::$prefix . 'servicer_member')->cols(['online' => 0, 'client_id' => ''])->query();
+    }
+
+    /**
+     * 当客户端连接时触发
+     * 如果业务不需此回调可以删除onConnect
+     * @param int $client_id 连接id
+     */
+    public static function onConnect($client_id)
+    {
+        $message = json_encode(['type' => 'init', 'data' => ['client_id' => $client_id]]);
+        // 向当前client_id发送数据
+        Gateway::sendToClient($client_id, $message);
+    }
+
+    /**
+     * 当客户端发来消息时触发
+     * @param int $client_id 连接id
+     * @param mixed $message 具体消息
+     */
+    public static function onMessage($client_id, $message)
+    {
+        // 向所有人发送
+        // Gateway::sendToAll("$client_id said $message\r\n");
+    }
+
+    /**
+     * 当用户断开连接时触发
+     * @param int $client_id 连接id
+     */
+    public static function onClose($client_id)
+    {
+        //用户下线处理
+        $servicer_member_info = self::$db->select('*')->from(self::$prefix . 'servicer_member')->where("client_id = '$client_id' ")->row();
+        if(!empty($servicer_member_info)){
+            @self::$db->update(self::$prefix . 'servicer_member')->cols(['online' => 0, 'client_id' => ''])->where("client_id = '$client_id' ")->query();
+            Gateway::sendToUid('ns_servicer_' . $servicer_member_info[ 'servicer_id' ], json_encode([ 'type' => 'disconnect', 'data' => [ 'member_id' => $servicer_member_info['member_id'] ] ]));
+            return;
+        }
+
+        //客服下线处理
+        @self::$db->update(self::$prefix . 'servicer')->cols(['online' => 0, 'client_id' => ''])->where("client_id = '$client_id' ")->query();
+    }
+}

app/gateway/service/start_businessworker.php

@@ -0,0 +1,35 @@
+<?php
+
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @link http://www.workerman.net/
+ * @license http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+
+use GatewayWorker\BusinessWorker;
+use Workerman\Worker;
+
+// 自动加载类
+require_once __DIR__ . '/../vendor/autoload.php';
+$config_info = require __DIR__ . '/../../../config/gateway.php';
+
+// bussinessWorker 进程
+$worker = new BusinessWorker();
+// worker名称
+$worker->name = $config_info['worker']['name'];
+// bussinessWorker进程数量
+$worker->count = $config_info['worker']['count'];
+// 服务注册地址
+$worker->registerAddress = $config_info['worker']['register_address'];
+
+// 如果不是在根目录启动，则运行runAll方法
+if (!defined('GLOBAL_START')) {
+    Worker::runAll();
+}

app/gateway/service/start_gateway.php

@@ -0,0 +1,81 @@
+<?php
+
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @link http://www.workerman.net/
+ * @license http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+
+use GatewayWorker\Gateway;
+use Workerman\Worker;
+
+// 自动加载类
+require_once __DIR__ . '/../vendor/autoload.php';
+$config_info = require __DIR__ . '/../../../config/gateway.php';
+
+if ($config_info['ssl'] && $config_info['ssl']['enable']) {
+    $context = [
+        'ssl' => [
+            'local_cert' => $config_info['ssl']['cert'], // 也可以是crt文件
+            'local_pk' => $config_info['ssl']['key'],
+            'verify_peer' => false
+        ]
+    ];
+
+    $gateway = new Gateway($config_info['gateway']['socket_name'], $context);
+    $gateway->transport = 'ssl';
+} else {
+    // gateway 进程，这里使用Text协议，可以用telnet测试
+    $gateway = new Gateway($config_info['gateway']['socket_name']);
+}
+
+// gateway名称，status方便查看
+$gateway->name = $config_info['gateway']['name'];
+// gateway进程数
+$gateway->count = $config_info['gateway']['count'];
+// 本机ip，分布式部署时使用内网ip
+$gateway->lanIp = $config_info['gateway']['lan_ip'];
+// 内部通讯起始端口，假如$gateway->count=4，起始端口为4000
+// 则一般会使用4000 4001 4002 4003 4个端口作为内部通讯端口
+$gateway->startPort = $config_info['gateway']['start_port'];;
+// 服务注册地址
+$gateway->registerAddress = $config_info['gateway']['register_address'];
+
+// 心跳间隔
+$gateway->pingInterval = $config_info['gateway']['ping_interval'];
+$gateway->pingNotResponseLimit = $config_info['gateway']['ping_not_response_limit'];
+// 心跳数据
+$gateway->pingData = $config_info['gateway']['ping_data'];
+
+/* 
+// 当客户端连接上来时，设置连接的onWebSocketConnect，即在websocket握手时的回调
+$gateway->onConnect = function($connection)
+{
+    $connection->onWebSocketConnect = function($connection , $http_header)
+    {
+        // 可以在这里判断连接来源是否合法，不合法就关掉连接
+        // $_SERVER['HTTP_ORIGIN']标识来自哪个站点的页面发起的websocket链接
+        if($_SERVER['HTTP_ORIGIN'] != 'http://kedou.workerman.net')
+        {
+            $connection->close();
+        }
+        // onWebSocketConnect 里面$_GET $_SERVER是可用的
+        // var_dump($_GET, $_SERVER);
+    };
+}; 
+*/
+
+// 如果不是在根目录启动，则运行runAll方法
+if (!defined('GLOBAL_START')) {
+    Worker::runAll();
+}
+
+
+

app/gateway/service/start_register.php

@@ -0,0 +1,31 @@
+<?php
+
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @link http://www.workerman.net/
+ * @license http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+
+use \Workerman\Worker;
+use \GatewayWorker\Register;
+
+// 自动加载类
+require_once __DIR__ . '/../vendor/autoload.php';
+$config_info = require __DIR__ . '/../../../config/gateway.php';
+
+// register 必须是text协议
+$register = new Register($config_info['register']['socket_name']);
+
+$register->name = $config_info['register']['name'] ?? 'Register';
+
+// 如果不是在根目录启动，则运行runAll方法
+if (!defined('GLOBAL_START')) {
+    Worker::runAll();
+}

app/gateway/start.php

@@ -0,0 +1,37 @@
+<?php
+/**
+ * run with command
+ * php start.php start
+ */
+
+ini_set('display_errors', 'on');
+use Workerman\Worker;
+
+if(strpos(strtolower(PHP_OS), 'win') === 0)
+{
+    exit("start.php not support windows, please use start_for_win.bat\n");
+}
+
+// 检查扩展
+if(!extension_loaded('pcntl'))
+{
+    exit("Please install pcntl extension. See http://doc3.workerman.net/appendices/install-extension.html\n");
+}
+
+if(!extension_loaded('posix'))
+{
+    exit("Please install posix extension. See http://doc3.workerman.net/appendices/install-extension.html\n");
+}
+
+// 标记是全局启动
+define('GLOBAL_START', 1);
+
+require_once __DIR__ . '/vendor/autoload.php';
+
+// 加载所有Applications/*/start.php，以便启动所有服务
+foreach(glob(__DIR__.'/service/start*.php') as $start_file)
+{
+    require_once $start_file;
+}
+// 运行所有服务
+Worker::runAll();

app/gateway/start_for_win.bat

@@ -0,0 +1,2 @@
+php service\start_register.php service\start_gateway.php service\start_businessworker.php
+pause

app/gateway/vendor/autoload.php

@@ -0,0 +1,7 @@
+<?php
+
+// autoload.php @generated by Composer
+
+require_once __DIR__ . '/composer/autoload_real.php';
+
+return ComposerAutoloaderInitdc1c91a408cc9646a71160fe2951fbb6::getLoader();

app/gateway/vendor/composer/ClassLoader.php

@@ -0,0 +1,445 @@
+<?php
+
+/*
+ * This file is part of Composer.
+ *
+ * (c) Nils Adermann <naderman@naderman.de>
+ *     Jordi Boggiano <j.boggiano@seld.be>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Composer\Autoload;
+
+/**
+ * ClassLoader implements a PSR-0, PSR-4 and classmap class loader.
+ *
+ *     $loader = new \Composer\Autoload\ClassLoader();
+ *
+ *     // register classes with namespaces
+ *     $loader->add('Symfony\Component', __DIR__.'/component');
+ *     $loader->add('Symfony',           __DIR__.'/framework');
+ *
+ *     // activate the autoloader
+ *     $loader->register();
+ *
+ *     // to enable searching the include path (eg. for PEAR packages)
+ *     $loader->setUseIncludePath(true);
+ *
+ * In this example, if you try to use a class in the Symfony\Component
+ * namespace or one of its children (Symfony\Component\Console for instance),
+ * the autoloader will first look for the class under the component/
+ * directory, and it will then fallback to the framework/ directory if not
+ * found before giving up.
+ *
+ * This class is loosely based on the Symfony UniversalClassLoader.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ * @author Jordi Boggiano <j.boggiano@seld.be>
+ * @see    http://www.php-fig.org/psr/psr-0/
+ * @see    http://www.php-fig.org/psr/psr-4/
+ */
+class ClassLoader
+{
+    // PSR-4
+    private $prefixLengthsPsr4 = array();
+    private $prefixDirsPsr4 = array();
+    private $fallbackDirsPsr4 = array();
+
+    // PSR-0
+    private $prefixesPsr0 = array();
+    private $fallbackDirsPsr0 = array();
+
+    private $useIncludePath = false;
+    private $classMap = array();
+    private $classMapAuthoritative = false;
+    private $missingClasses = array();
+    private $apcuPrefix;
+
+    public function getPrefixes()
+    {
+        if (!empty($this->prefixesPsr0)) {
+            return call_user_func_array('array_merge', $this->prefixesPsr0);
+        }
+
+        return array();
+    }
+
+    public function getPrefixesPsr4()
+    {
+        return $this->prefixDirsPsr4;
+    }
+
+    public function getFallbackDirs()
+    {
+        return $this->fallbackDirsPsr0;
+    }
+
+    public function getFallbackDirsPsr4()
+    {
+        return $this->fallbackDirsPsr4;
+    }
+
+    public function getClassMap()
+    {
+        return $this->classMap;
+    }
+
+    /**
+     * @param array $classMap Class to filename map
+     */
+    public function addClassMap(array $classMap)
+    {
+        if ($this->classMap) {
+            $this->classMap = array_merge($this->classMap, $classMap);
+        } else {
+            $this->classMap = $classMap;
+        }
+    }
+
+    /**
+     * Registers a set of PSR-0 directories for a given prefix, either
+     * appending or prepending to the ones previously set for this prefix.
+     *
+     * @param string       $prefix  The prefix
+     * @param array|string $paths   The PSR-0 root directories
+     * @param bool         $prepend Whether to prepend the directories
+     */
+    public function add($prefix, $paths, $prepend = false)
+    {
+        if (!$prefix) {
+            if ($prepend) {
+                $this->fallbackDirsPsr0 = array_merge(
+                    (array) $paths,
+                    $this->fallbackDirsPsr0
+                );
+            } else {
+                $this->fallbackDirsPsr0 = array_merge(
+                    $this->fallbackDirsPsr0,
+                    (array) $paths
+                );
+            }
+
+            return;
+        }
+
+        $first = $prefix[0];
+        if (!isset($this->prefixesPsr0[$first][$prefix])) {
+            $this->prefixesPsr0[$first][$prefix] = (array) $paths;
+
+            return;
+        }
+        if ($prepend) {
+            $this->prefixesPsr0[$first][$prefix] = array_merge(
+                (array) $paths,
+                $this->prefixesPsr0[$first][$prefix]
+            );
+        } else {
+            $this->prefixesPsr0[$first][$prefix] = array_merge(
+                $this->prefixesPsr0[$first][$prefix],
+                (array) $paths
+            );
+        }
+    }
+
+    /**
+     * Registers a set of PSR-4 directories for a given namespace, either
+     * appending or prepending to the ones previously set for this namespace.
+     *
+     * @param string       $prefix  The prefix/namespace, with trailing '\\'
+     * @param array|string $paths   The PSR-4 base directories
+     * @param bool         $prepend Whether to prepend the directories
+     *
+     * @throws \InvalidArgumentException
+     */
+    public function addPsr4($prefix, $paths, $prepend = false)
+    {
+        if (!$prefix) {
+            // Register directories for the root namespace.
+            if ($prepend) {
+                $this->fallbackDirsPsr4 = array_merge(
+                    (array) $paths,
+                    $this->fallbackDirsPsr4
+                );
+            } else {
+                $this->fallbackDirsPsr4 = array_merge(
+                    $this->fallbackDirsPsr4,
+                    (array) $paths
+                );
+            }
+        } elseif (!isset($this->prefixDirsPsr4[$prefix])) {
+            // Register directories for a new namespace.
+            $length = strlen($prefix);
+            if ('\\' !== $prefix[$length - 1]) {
+                throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator.");
+            }
+            $this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length;
+            $this->prefixDirsPsr4[$prefix] = (array) $paths;
+        } elseif ($prepend) {
+            // Prepend directories for an already registered namespace.
+            $this->prefixDirsPsr4[$prefix] = array_merge(
+                (array) $paths,
+                $this->prefixDirsPsr4[$prefix]
+            );
+        } else {
+            // Append directories for an already registered namespace.
+            $this->prefixDirsPsr4[$prefix] = array_merge(
+                $this->prefixDirsPsr4[$prefix],
+                (array) $paths
+            );
+        }
+    }
+
+    /**
+     * Registers a set of PSR-0 directories for a given prefix,
+     * replacing any others previously set for this prefix.
+     *
+     * @param string       $prefix The prefix
+     * @param array|string $paths  The PSR-0 base directories
+     */
+    public function set($prefix, $paths)
+    {
+        if (!$prefix) {
+            $this->fallbackDirsPsr0 = (array) $paths;
+        } else {
+            $this->prefixesPsr0[$prefix[0]][$prefix] = (array) $paths;
+        }
+    }
+
+    /**
+     * Registers a set of PSR-4 directories for a given namespace,
+     * replacing any others previously set for this namespace.
+     *
+     * @param string       $prefix The prefix/namespace, with trailing '\\'
+     * @param array|string $paths  The PSR-4 base directories
+     *
+     * @throws \InvalidArgumentException
+     */
+    public function setPsr4($prefix, $paths)
+    {
+        if (!$prefix) {
+            $this->fallbackDirsPsr4 = (array) $paths;
+        } else {
+            $length = strlen($prefix);
+            if ('\\' !== $prefix[$length - 1]) {
+                throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator.");
+            }
+            $this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length;
+            $this->prefixDirsPsr4[$prefix] = (array) $paths;
+        }
+    }
+
+    /**
+     * Turns on searching the include path for class files.
+     *
+     * @param bool $useIncludePath
+     */
+    public function setUseIncludePath($useIncludePath)
+    {
+        $this->useIncludePath = $useIncludePath;
+    }
+
+    /**
+     * Can be used to check if the autoloader uses the include path to check
+     * for classes.
+     *
+     * @return bool
+     */
+    public function getUseIncludePath()
+    {
+        return $this->useIncludePath;
+    }
+
+    /**
+     * Turns off searching the prefix and fallback directories for classes
+     * that have not been registered with the class map.
+     *
+     * @param bool $classMapAuthoritative
+     */
+    public function setClassMapAuthoritative($classMapAuthoritative)
+    {
+        $this->classMapAuthoritative = $classMapAuthoritative;
+    }
+
+    /**
+     * Should class lookup fail if not found in the current class map?
+     *
+     * @return bool
+     */
+    public function isClassMapAuthoritative()
+    {
+        return $this->classMapAuthoritative;
+    }
+
+    /**
+     * APCu prefix to use to cache found/not-found classes, if the extension is enabled.
+     *
+     * @param string|null $apcuPrefix
+     */
+    public function setApcuPrefix($apcuPrefix)
+    {
+        $this->apcuPrefix = function_exists('apcu_fetch') && filter_var(ini_get('apc.enabled'), FILTER_VALIDATE_BOOLEAN) ? $apcuPrefix : null;
+    }
+
+    /**
+     * The APCu prefix in use, or null if APCu caching is not enabled.
+     *
+     * @return string|null
+     */
+    public function getApcuPrefix()
+    {
+        return $this->apcuPrefix;
+    }
+
+    /**
+     * Registers this instance as an autoloader.
+     *
+     * @param bool $prepend Whether to prepend the autoloader or not
+     */
+    public function register($prepend = false)
+    {
+        spl_autoload_register(array($this, 'loadClass'), true, $prepend);
+    }
+
+    /**
+     * Unregisters this instance as an autoloader.
+     */
+    public function unregister()
+    {
+        spl_autoload_unregister(array($this, 'loadClass'));
+    }
+
+    /**
+     * Loads the given class or interface.
+     *
+     * @param  string    $class The name of the class
+     * @return bool|null True if loaded, null otherwise
+     */
+    public function loadClass($class)
+    {
+        if ($file = $this->findFile($class)) {
+            includeFile($file);
+
+            return true;
+        }
+    }
+
+    /**
+     * Finds the path to the file where the class is defined.
+     *
+     * @param string $class The name of the class
+     *
+     * @return string|false The path if found, false otherwise
+     */
+    public function findFile($class)
+    {
+        // class map lookup
+        if (isset($this->classMap[$class])) {
+            return $this->classMap[$class];
+        }
+        if ($this->classMapAuthoritative || isset($this->missingClasses[$class])) {
+            return false;
+        }
+        if (null !== $this->apcuPrefix) {
+            $file = apcu_fetch($this->apcuPrefix.$class, $hit);
+            if ($hit) {
+                return $file;
+            }
+        }
+
+        $file = $this->findFileWithExtension($class, '.php');
+
+        // Search for Hack files if we are running on HHVM
+        if (false === $file && defined('HHVM_VERSION')) {
+            $file = $this->findFileWithExtension($class, '.hh');
+        }
+
+        if (null !== $this->apcuPrefix) {
+            apcu_add($this->apcuPrefix.$class, $file);
+        }
+
+        if (false === $file) {
+            // Remember that this class does not exist.
+            $this->missingClasses[$class] = true;
+        }
+
+        return $file;
+    }
+
+    private function findFileWithExtension($class, $ext)
+    {
+        // PSR-4 lookup
+        $logicalPathPsr4 = strtr($class, '\\', DIRECTORY_SEPARATOR) . $ext;
+
+        $first = $class[0];
+        if (isset($this->prefixLengthsPsr4[$first])) {
+            $subPath = $class;
+            while (false !== $lastPos = strrpos($subPath, '\\')) {
+                $subPath = substr($subPath, 0, $lastPos);
+                $search = $subPath . '\\';
+                if (isset($this->prefixDirsPsr4[$search])) {
+                    $pathEnd = DIRECTORY_SEPARATOR . substr($logicalPathPsr4, $lastPos + 1);
+                    foreach ($this->prefixDirsPsr4[$search] as $dir) {
+                        if (file_exists($file = $dir . $pathEnd)) {
+                            return $file;
+                        }
+                    }
+                }
+            }
+        }
+
+        // PSR-4 fallback dirs
+        foreach ($this->fallbackDirsPsr4 as $dir) {
+            if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr4)) {
+                return $file;
+            }
+        }
+
+        // PSR-0 lookup
+        if (false !== $pos = strrpos($class, '\\')) {
+            // namespaced class name
+            $logicalPathPsr0 = substr($logicalPathPsr4, 0, $pos + 1)
+                . strtr(substr($logicalPathPsr4, $pos + 1), '_', DIRECTORY_SEPARATOR);
+        } else {
+            // PEAR-like class name
+            $logicalPathPsr0 = strtr($class, '_', DIRECTORY_SEPARATOR) . $ext;
+        }
+
+        if (isset($this->prefixesPsr0[$first])) {
+            foreach ($this->prefixesPsr0[$first] as $prefix => $dirs) {
+                if (0 === strpos($class, $prefix)) {
+                    foreach ($dirs as $dir) {
+                        if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) {
+                            return $file;
+                        }
+                    }
+                }
+            }
+        }
+
+        // PSR-0 fallback dirs
+        foreach ($this->fallbackDirsPsr0 as $dir) {
+            if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) {
+                return $file;
+            }
+        }
+
+        // PSR-0 include paths.
+        if ($this->useIncludePath && $file = stream_resolve_include_path($logicalPathPsr0)) {
+            return $file;
+        }
+
+        return false;
+    }
+}
+
+/**
+ * Scope isolated include.
+ *
+ * Prevents access to $this/self from included files.
+ */
+function includeFile($file)
+{
+    include $file;
+}

app/gateway/vendor/composer/LICENSE

@@ -0,0 +1,21 @@
+
+Copyright (c) Nils Adermann, Jordi Boggiano
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished
+to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+

app/gateway/vendor/composer/autoload_classmap.php

@@ -0,0 +1,9 @@
+<?php
+
+// autoload_classmap.php @generated by Composer
+
+$vendorDir = dirname(dirname(__FILE__));
+$baseDir = dirname($vendorDir);
+
+return array(
+);

app/gateway/vendor/composer/autoload_namespaces.php

@@ -0,0 +1,9 @@
+<?php
+
+// autoload_namespaces.php @generated by Composer
+
+$vendorDir = dirname(dirname(__FILE__));
+$baseDir = dirname($vendorDir);
+
+return array(
+);

app/gateway/vendor/composer/autoload_psr4.php

@@ -0,0 +1,12 @@
+<?php
+
+// autoload_psr4.php @generated by Composer
+
+$vendorDir = dirname(dirname(__FILE__));
+$baseDir = dirname($vendorDir);
+
+return array(
+    'Workerman\\MySQL\\' => array($vendorDir . '/workerman/mysql/src'),
+    'Workerman\\' => array($vendorDir . '/workerman/workerman'),
+    'GatewayWorker\\' => array($vendorDir . '/workerman/gateway-worker/src'),
+);

app/gateway/vendor/composer/autoload_real.php

@@ -0,0 +1,55 @@
+<?php
+
+// autoload_real.php @generated by Composer
+
+class ComposerAutoloaderInitdc1c91a408cc9646a71160fe2951fbb6
+{
+    private static $loader;
+
+    public static function loadClassLoader($class)
+    {
+        if ('Composer\Autoload\ClassLoader' === $class) {
+            require __DIR__ . '/ClassLoader.php';
+        }
+    }
+
+    /**
+     * @return \Composer\Autoload\ClassLoader
+     */
+    public static function getLoader()
+    {
+        if (null !== self::$loader) {
+            return self::$loader;
+        }
+
+        spl_autoload_register(array('ComposerAutoloaderInitdc1c91a408cc9646a71160fe2951fbb6', 'loadClassLoader'), true, true);
+        self::$loader = $loader = new \Composer\Autoload\ClassLoader();
+        spl_autoload_unregister(array('ComposerAutoloaderInitdc1c91a408cc9646a71160fe2951fbb6', 'loadClassLoader'));
+
+        $useStaticLoader = PHP_VERSION_ID >= 50600 && !defined('HHVM_VERSION') && (!function_exists('zend_loader_file_encoded') || !zend_loader_file_encoded());
+        if ($useStaticLoader) {
+            require_once __DIR__ . '/autoload_static.php';
+
+            call_user_func(\Composer\Autoload\ComposerStaticInitdc1c91a408cc9646a71160fe2951fbb6::getInitializer($loader));
+        } else {
+            $map = require __DIR__ . '/autoload_namespaces.php';
+            foreach ($map as $namespace => $path) {
+                $loader->set($namespace, $path);
+            }
+
+            $map = require __DIR__ . '/autoload_psr4.php';
+            foreach ($map as $namespace => $path) {
+                $loader->setPsr4($namespace, $path);
+            }
+
+            $classMap = require __DIR__ . '/autoload_classmap.php';
+            if ($classMap) {
+                $loader->addClassMap($classMap);
+            }
+        }
+
+        $loader->register(true);
+
+        return $loader;
+    }
+}

app/gateway/vendor/composer/autoload_static.php

@@ -0,0 +1,44 @@
+<?php
+
+// autoload_static.php @generated by Composer
+
+namespace Composer\Autoload;
+
+class ComposerStaticInitdc1c91a408cc9646a71160fe2951fbb6
+{
+    public static $prefixLengthsPsr4 = array (
+        'W' => 
+        array (
+            'Workerman\\MySQL\\' => 16,
+            'Workerman\\' => 10,
+        ),
+        'G' => 
+        array (
+            'GatewayWorker\\' => 14,
+        ),
+    );
+
+    public static $prefixDirsPsr4 = array (
+        'Workerman\\MySQL\\' => 
+        array (
+            0 => __DIR__ . '/..' . '/workerman/mysql/src',
+        ),
+        'Workerman\\' => 
+        array (
+            0 => __DIR__ . '/..' . '/workerman/workerman',
+        ),
+        'GatewayWorker\\' => 
+        array (
+            0 => __DIR__ . '/..' . '/workerman/gateway-worker/src',
+        ),
+    );
+
+    public static function getInitializer(ClassLoader $loader)
+    {
+        return \Closure::bind(function () use ($loader) {
+            $loader->prefixLengthsPsr4 = ComposerStaticInitdc1c91a408cc9646a71160fe2951fbb6::$prefixLengthsPsr4;
+            $loader->prefixDirsPsr4 = ComposerStaticInitdc1c91a408cc9646a71160fe2951fbb6::$prefixDirsPsr4;
+
+        }, null, ClassLoader::class);
+    }
+}

app/gateway/vendor/composer/installed.json

@@ -0,0 +1,144 @@
+[
+    {
+        "name": "workerman/gateway-worker",
+        "version": "v3.0.16",
+        "version_normalized": "3.0.16.0",
+        "source": {
+            "type": "git",
+            "url": "https://github.com/walkor/GatewayWorker.git",
+            "reference": "f153c28c76cf60cc882d6b66f89b622176268fb7"
+        },
+        "dist": {
+            "type": "zip",
+            "url": "https://api.github.com/repos/walkor/GatewayWorker/zipball/f153c28c76cf60cc882d6b66f89b622176268fb7",
+            "reference": "f153c28c76cf60cc882d6b66f89b622176268fb7",
+            "shasum": "",
+            "mirrors": [
+                {
+                    "url": "https://mirrors.aliyun.com/composer/dists/%package%/%reference%.%type%",
+                    "preferred": true
+                }
+            ]
+        },
+        "require": {
+            "workerman/workerman": ">=3.5.0"
+        },
+        "time": "2020-06-04T02:58:35+00:00",
+        "type": "library",
+        "installation-source": "dist",
+        "autoload": {
+            "psr-4": {
+                "GatewayWorker\\": "./src"
+            }
+        },
+        "notification-url": "https://packagist.org/downloads/",
+        "license": [
+            "MIT"
+        ],
+        "homepage": "http://www.workerman.net",
+        "keywords": [
+            "communication",
+            "distributed"
+        ]
+    },
+    {
+        "name": "workerman/mysql",
+        "version": "v1.0.6",
+        "version_normalized": "1.0.6.0",
+        "source": {
+            "type": "git",
+            "url": "https://github.com/walkor/mysql.git",
+            "reference": "28272aa68f9ea1a482f9bb0cf709d169f772d228"
+        },
+        "dist": {
+            "type": "zip",
+            "url": "https://api.github.com/repos/walkor/mysql/zipball/28272aa68f9ea1a482f9bb0cf709d169f772d228",
+            "reference": "28272aa68f9ea1a482f9bb0cf709d169f772d228",
+            "shasum": "",
+            "mirrors": [
+                {
+                    "url": "https://mirrors.aliyun.com/composer/dists/%package%/%reference%.%type%",
+                    "preferred": true
+                }
+            ]
+        },
+        "require": {
+            "ext-pdo": "*",
+            "ext-pdo_mysql": "*",
+            "php": ">=5.3"
+        },
+        "time": "2019-08-02T10:43:09+00:00",
+        "type": "library",
+        "installation-source": "dist",
+        "autoload": {
+            "psr-4": {
+                "Workerman\\MySQL\\": "./src"
+            }
+        },
+        "notification-url": "https://packagist.org/downloads/",
+        "license": [
+            "MIT"
+        ],
+        "description": "Long-living MySQL connection for daemon.",
+        "homepage": "http://www.workerman.net",
+        "keywords": [
+            "mysql",
+            "pdo",
+            "pdo_mysql"
+        ]
+    },
+    {
+        "name": "workerman/workerman",
+        "version": "v4.0.6",
+        "version_normalized": "4.0.6.0",
+        "source": {
+            "type": "git",
+            "url": "https://github.com/walkor/Workerman.git",
+            "reference": "14964ed1f3655e10f8bd0bd45e78fb75104fc9cf"
+        },
+        "dist": {
+            "type": "zip",
+            "url": "https://api.github.com/repos/walkor/Workerman/zipball/14964ed1f3655e10f8bd0bd45e78fb75104fc9cf",
+            "reference": "14964ed1f3655e10f8bd0bd45e78fb75104fc9cf",
+            "shasum": "",
+            "mirrors": [
+                {
+                    "url": "https://mirrors.aliyun.com/composer/dists/%package%/%reference%.%type%",
+                    "preferred": true
+                }
+            ]
+        },
+        "require": {
+            "php": ">=5.3"
+        },
+        "suggest": {
+            "ext-event": "For better performance. "
+        },
+        "time": "2020-06-12T16:21:56+00:00",
+        "type": "library",
+        "installation-source": "dist",
+        "autoload": {
+            "psr-4": {
+                "Workerman\\": "./"
+            }
+        },
+        "notification-url": "https://packagist.org/downloads/",
+        "license": [
+            "MIT"
+        ],
+        "authors": [
+            {
+                "name": "walkor",
+                "email": "walkor@workerman.net",
+                "homepage": "http://www.workerman.net",
+                "role": "Developer"
+            }
+        ],
+        "description": "An asynchronous event driven PHP framework for easily building fast, scalable network applications.",
+        "homepage": "http://www.workerman.net",
+        "keywords": [
+            "asynchronous",
+            "event-loop"
+        ]
+    }
+]

app/gateway/vendor/workerman/gateway-worker/.gitignore

@@ -0,0 +1,4 @@
+.buildpath
+.project
+.settings
+.idea

app/gateway/vendor/workerman/gateway-worker/README.md

@@ -0,0 +1,38 @@
+GatewayWorker 
+=================
+
+GatewayWorker基于[Workerman](https://github.com/walkor/Workerman)开发的一个项目框架，用于快速开发长连接应用，例如app推送服务端、即时IM服务端、游戏服务端、物联网、智能家居等等。
+
+GatewayWorker使用经典的Gateway和Worker进程模型。Gateway进程负责维持客户端连接，并转发客户端的数据给Worker进程处理；Worker进程负责处理实际的业务逻辑，并将结果推送给对应的客户端。Gateway服务和Worker服务可以分开部署在不同的服务器上，实现分布式集群。
+
+GatewayWorker提供非常方便的API，可以全局广播数据、可以向某个群体广播数据、也可以向某个特定客户端推送数据。配合Workerman的定时器，也可以定时推送数据。
+
+快速开始
+======
+开发者可以从一个简单的demo开始(demo中包含了GatewayWorker内核，以及start_gateway.php start_business.php等启动入口文件)<br>
+[点击这里下载demo](http://www.workerman.net/download/GatewayWorker.zip)。<br>
+demo说明见源码readme。
+
+手册
+=======
+http://www.workerman.net/gatewaydoc/
+
+安装内核
+=======
+
+只安装GatewayWorker内核文件（不包含start_gateway.php start_businessworker.php等启动入口文件）
+```
+composer require workerman/gateway-worker
+```
+
+使用GatewayWorker开发的项目
+=======
+## [tadpole](http://kedou.workerman.net/)  
+[Live demo](http://kedou.workerman.net/)  
+[Source code](https://github.com/walkor/workerman)  
+![workerman todpole](http://www.workerman.net/img/workerman-todpole.png)   
+
+## [chat room](http://chat.workerman.net/)  
+[Live demo](http://chat.workerman.net/)  
+[Source code](https://github.com/walkor/workerman-chat)  
+![workerman-chat](http://www.workerman.net/img/workerman-chat.png)  

app/gateway/vendor/workerman/gateway-worker/composer.json

@@ -0,0 +1,12 @@
+{
+    "name"  : "workerman/gateway-worker",
+    "keywords": ["distributed","communication"],
+    "homepage": "http://www.workerman.net",
+    "license" : "MIT",
+    "require": {
+        "workerman/workerman" : ">=3.5.0"
+    },
+    "autoload": {
+        "psr-4": {"GatewayWorker\\": "./src"}
+    }
+}

app/gateway/vendor/workerman/gateway-worker/src/BusinessWorker.php

@@ -0,0 +1,561 @@
+<?php
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author    walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @link      http://www.workerman.net/
+ * @license   http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+namespace GatewayWorker;
+
+use Workerman\Connection\TcpConnection;
+
+use Workerman\Worker;
+use Workerman\Lib\Timer;
+use Workerman\Connection\AsyncTcpConnection;
+use GatewayWorker\Protocols\GatewayProtocol;
+use GatewayWorker\Lib\Context;
+
+/**
+ *
+ * BusinessWorker 用于处理Gateway转发来的数据
+ *
+ * @author walkor<walkor@workerman.net>
+ *
+ */
+class BusinessWorker extends Worker
+{
+    /**
+     * 保存与 gateway 的连接 connection 对象
+     *
+     * @var array
+     */
+    public $gatewayConnections = array();
+
+    /**
+     * 注册中心地址
+     *
+     * @var string|array
+     */
+    public $registerAddress = '127.0.0.1:1236';
+
+    /**
+     * 事件处理类，默认是 Event 类
+     *
+     * @var string
+     */
+    public $eventHandler = 'Events';
+
+    /**
+     * 业务超时时间，可用来定位程序卡在哪里
+     *
+     * @var int
+     */
+    public $processTimeout = 30;
+
+    /**
+     * 业务超时时间，可用来定位程序卡在哪里
+     *
+     * @var callable
+     */
+    public $processTimeoutHandler = '\\Workerman\\Worker::log';
+    
+    /**
+     * 秘钥
+     *
+     * @var string
+     */
+    public $secretKey = '';
+
+    /**
+     * businessWorker进程将消息转发给gateway进程的发送缓冲区大小
+     *
+     * @var int
+     */
+    public $sendToGatewayBufferSize = 10240000;
+
+    /**
+     * 保存用户设置的 worker 启动回调
+     *
+     * @var callback
+     */
+    protected $_onWorkerStart = null;
+
+    /**
+     * 保存用户设置的 workerReload 回调
+     *
+     * @var callback
+     */
+    protected $_onWorkerReload = null;
+    
+    /**
+     * 保存用户设置的 workerStop 回调
+     *
+     * @var callback
+     */
+    protected $_onWorkerStop= null;
+
+    /**
+     * 到注册中心的连接
+     *
+     * @var AsyncTcpConnection
+     */
+    protected $_registerConnection = null;
+
+    /**
+     * 处于连接状态的 gateway 通讯地址
+     *
+     * @var array
+     */
+    protected $_connectingGatewayAddresses = array();
+
+    /**
+     * 所有 geteway 内部通讯地址
+     *
+     * @var array
+     */
+    protected $_gatewayAddresses = array();
+
+    /**
+     * 等待连接个 gateway 地址
+     *
+     * @var array
+     */
+    protected $_waitingConnectGatewayAddresses = array();
+
+    /**
+     * Event::onConnect 回调
+     *
+     * @var callback
+     */
+    protected $_eventOnConnect = null;
+
+    /**
+     * Event::onMessage 回调
+     *
+     * @var callback
+     */
+    protected $_eventOnMessage = null;
+
+    /**
+     * Event::onClose 回调
+     *
+     * @var callback
+     */
+    protected $_eventOnClose = null;
+
+    /**
+     * websocket回调
+     *
+     * @var null
+     */
+    protected $_eventOnWebSocketConnect = null;
+
+    /**
+     * SESSION 版本缓存
+     *
+     * @var array
+     */
+    protected $_sessionVersion = array();
+
+    /**
+     * 用于保持长连接的心跳时间间隔
+     *
+     * @var int
+     */
+    const PERSISTENCE_CONNECTION_PING_INTERVAL = 25;
+
+    /**
+     * 构造函数
+     *
+     * @param string $socket_name
+     * @param array  $context_option
+     */
+    public function __construct($socket_name = '', $context_option = array())
+    {
+        parent::__construct($socket_name, $context_option);
+        $backrace                = debug_backtrace();
+        $this->_autoloadRootPath = dirname($backrace[0]['file']);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function run()
+    {
+        $this->_onWorkerStart  = $this->onWorkerStart;
+        $this->_onWorkerReload = $this->onWorkerReload;
+        $this->_onWorkerStop = $this->onWorkerStop;
+        $this->onWorkerStop   = array($this, 'onWorkerStop');
+        $this->onWorkerStart   = array($this, 'onWorkerStart');
+        $this->onWorkerReload  = array($this, 'onWorkerReload');
+        parent::run();
+    }
+
+    /**
+     * 当进程启动时一些初始化工作
+     *
+     * @return void
+     */
+    protected function onWorkerStart()
+    {
+        if (!class_exists('\Protocols\GatewayProtocol')) {
+            class_alias('GatewayWorker\Protocols\GatewayProtocol', 'Protocols\GatewayProtocol');
+        }
+
+        if (!is_array($this->registerAddress)) {
+            $this->registerAddress = array($this->registerAddress);
+        }
+        $this->connectToRegister();
+
+        \GatewayWorker\Lib\Gateway::setBusinessWorker($this);
+        \GatewayWorker\Lib\Gateway::$secretKey = $this->secretKey;
+        if ($this->_onWorkerStart) {
+            call_user_func($this->_onWorkerStart, $this);
+        }
+        
+        if (is_callable($this->eventHandler . '::onWorkerStart')) {
+            call_user_func($this->eventHandler . '::onWorkerStart', $this);
+        }
+
+        if (function_exists('pcntl_signal')) {
+            // 业务超时信号处理
+            pcntl_signal(SIGALRM, array($this, 'timeoutHandler'), false);
+        } else {
+            $this->processTimeout = 0;
+        }
+
+        // 设置回调
+        if (is_callable($this->eventHandler . '::onConnect')) {
+            $this->_eventOnConnect = $this->eventHandler . '::onConnect';
+        }
+
+        if (is_callable($this->eventHandler . '::onMessage')) {
+            $this->_eventOnMessage = $this->eventHandler . '::onMessage';
+        } else {
+            echo "Waring: {$this->eventHandler}::onMessage is not callable\n";
+        }
+
+        if (is_callable($this->eventHandler . '::onClose')) {
+            $this->_eventOnClose = $this->eventHandler . '::onClose';
+        }
+
+        if (is_callable($this->eventHandler . '::onWebSocketConnect')) {
+            $this->_eventOnWebSocketConnect = $this->eventHandler . '::onWebSocketConnect';
+        }
+
+    }
+
+    /**
+     * onWorkerReload 回调
+     *
+     * @param Worker $worker
+     */
+    protected function onWorkerReload($worker)
+    {
+        // 防止进程立刻退出
+        $worker->reloadable = false;
+        // 延迟 0.05 秒退出，避免 BusinessWorker 瞬间全部退出导致没有可用的 BusinessWorker 进程
+        Timer::add(0.05, array('Workerman\Worker', 'stopAll'));
+        // 执行用户定义的 onWorkerReload 回调
+        if ($this->_onWorkerReload) {
+            call_user_func($this->_onWorkerReload, $this);
+        }
+    }
+    
+    /**
+     * 当进程关闭时一些清理工作
+     *
+     * @return void
+     */
+    protected function onWorkerStop()
+    {
+        if ($this->_onWorkerStop) {
+            call_user_func($this->_onWorkerStop, $this);
+        }
+        if (is_callable($this->eventHandler . '::onWorkerStop')) {
+            call_user_func($this->eventHandler . '::onWorkerStop', $this);
+        }
+    }
+
+    /**
+     * 连接服务注册中心
+     * 
+     * @return void
+     */
+    public function connectToRegister()
+    {
+        foreach ($this->registerAddress as $register_address) {
+            $register_connection = new AsyncTcpConnection("text://{$register_address}");
+            $secret_key = $this->secretKey;
+            $register_connection->onConnect = function () use ($register_connection, $secret_key, $register_address) {
+                $register_connection->send('{"event":"worker_connect","secret_key":"' . $secret_key . '"}');
+                // 如果Register服务器不在本地服务器，则需要保持心跳
+                if (strpos($register_address, '127.0.0.1') !== 0) {
+                    $register_connection->ping_timer = Timer::add(self::PERSISTENCE_CONNECTION_PING_INTERVAL, function () use ($register_connection) {
+                        $register_connection->send('{"event":"ping"}');
+                    });
+                }
+            };
+            $register_connection->onClose = function ($register_connection) {
+                if(!empty($register_connection->ping_timer)) {
+                    Timer::del($register_connection->ping_timer);
+                }
+                $register_connection->reconnect(1);
+            };
+            $register_connection->onMessage = array($this, 'onRegisterConnectionMessage');
+            $register_connection->connect();
+        }
+    }
+
+
+    /**
+     * 当注册中心发来消息时
+     *
+     * @return void
+     */
+    public function onRegisterConnectionMessage($register_connection, $data)
+    {
+        $data = json_decode($data, true);
+        if (!isset($data['event'])) {
+            echo "Received bad data from Register\n";
+            return;
+        }
+        $event = $data['event'];
+        switch ($event) {
+            case 'broadcast_addresses':
+                if (!is_array($data['addresses'])) {
+                    echo "Received bad data from Register. Addresses empty\n";
+                    return;
+                }
+                $addresses               = $data['addresses'];
+                $this->_gatewayAddresses = array();
+                foreach ($addresses as $addr) {
+                    $this->_gatewayAddresses[$addr] = $addr;
+                }
+                $this->checkGatewayConnections($addresses);
+                break;
+            default:
+                echo "Receive bad event:$event from Register.\n";
+        }
+    }
+
+    /**
+     * 当 gateway 转发来数据时
+     *
+     * @param TcpConnection $connection
+     * @param mixed         $data
+     */
+    public function onGatewayMessage($connection, $data)
+    {
+        $cmd = $data['cmd'];
+        if ($cmd === GatewayProtocol::CMD_PING) {
+            return;
+        }
+        // 上下文数据
+        Context::$client_ip     = $data['client_ip'];
+        Context::$client_port   = $data['client_port'];
+        Context::$local_ip      = $data['local_ip'];
+        Context::$local_port    = $data['local_port'];
+        Context::$connection_id = $data['connection_id'];
+        Context::$client_id     = Context::addressToClientId($data['local_ip'], $data['local_port'],
+            $data['connection_id']);
+        // $_SERVER 变量
+        $_SERVER = array(
+            'REMOTE_ADDR'       => long2ip($data['client_ip']),
+            'REMOTE_PORT'       => $data['client_port'],
+            'GATEWAY_ADDR'      => long2ip($data['local_ip']),
+            'GATEWAY_PORT'      => $data['gateway_port'],
+            'GATEWAY_CLIENT_ID' => Context::$client_id,
+        );
+        // 检查session版本，如果是过期的session数据则拉取最新的数据
+        if ($cmd !== GatewayProtocol::CMD_ON_CLOSE && isset($this->_sessionVersion[Context::$client_id]) && $this->_sessionVersion[Context::$client_id] !== crc32($data['ext_data'])) {
+            $_SESSION = Context::$old_session = \GatewayWorker\Lib\Gateway::getSession(Context::$client_id);
+            $this->_sessionVersion[Context::$client_id] = crc32($data['ext_data']);
+        } else {
+            if (!isset($this->_sessionVersion[Context::$client_id])) {
+                $this->_sessionVersion[Context::$client_id] = crc32($data['ext_data']);
+            }
+            // 尝试解析 session
+            if ($data['ext_data'] != '') {
+                Context::$old_session = $_SESSION = Context::sessionDecode($data['ext_data']);
+            } else {
+                Context::$old_session = $_SESSION = null;
+            }
+        }
+
+        if ($this->processTimeout) {
+            pcntl_alarm($this->processTimeout);
+        }
+        // 尝试执行 Event::onConnection、Event::onMessage、Event::onClose
+        switch ($cmd) {
+            case GatewayProtocol::CMD_ON_CONNECT:
+                if ($this->_eventOnConnect) {
+                    call_user_func($this->_eventOnConnect, Context::$client_id);
+                }
+                break;
+            case GatewayProtocol::CMD_ON_MESSAGE:
+                if ($this->_eventOnMessage) {
+                    call_user_func($this->_eventOnMessage, Context::$client_id, $data['body']);
+                }
+                break;
+            case GatewayProtocol::CMD_ON_CLOSE:
+                unset($this->_sessionVersion[Context::$client_id]);
+                if ($this->_eventOnClose) {
+                    call_user_func($this->_eventOnClose, Context::$client_id);
+                }
+                break;
+            case GatewayProtocol::CMD_ON_WEBSOCKET_CONNECT:
+                if ($this->_eventOnWebSocketConnect) {
+                    call_user_func($this->_eventOnWebSocketConnect, Context::$client_id, $data['body']);
+                }
+                break;
+        }
+        if ($this->processTimeout) {
+            pcntl_alarm(0);
+        }
+        
+        // session 必须是数组
+        if ($_SESSION !== null && !is_array($_SESSION)) {
+            throw new \Exception('$_SESSION must be an array. But $_SESSION=' . var_export($_SESSION, true) . ' is not array.');
+        }
+
+        // 判断 session 是否被更改
+        if ($_SESSION !== Context::$old_session && $cmd !== GatewayProtocol::CMD_ON_CLOSE) {
+            $session_str_now = $_SESSION !== null ? Context::sessionEncode($_SESSION) : '';
+            \GatewayWorker\Lib\Gateway::setSocketSession(Context::$client_id, $session_str_now);
+            $this->_sessionVersion[Context::$client_id] = crc32($session_str_now);
+        }
+
+        Context::clear();
+    }
+
+    /**
+     * 当与 Gateway 的连接断开时触发
+     *
+     * @param TcpConnection $connection
+     * @return  void
+     */
+    public function onGatewayClose($connection)
+    {
+        $addr = $connection->remoteAddress;
+        unset($this->gatewayConnections[$addr], $this->_connectingGatewayAddresses[$addr]);
+        if (isset($this->_gatewayAddresses[$addr]) && !isset($this->_waitingConnectGatewayAddresses[$addr])) {
+            Timer::add(1, array($this, 'tryToConnectGateway'), array($addr), false);
+            $this->_waitingConnectGatewayAddresses[$addr] = $addr;
+        }
+    }
+
+    /**
+     * 尝试连接 Gateway 内部通讯地址
+     *
+     * @param string $addr
+     */
+    public function tryToConnectGateway($addr)
+    {
+        if (!isset($this->gatewayConnections[$addr]) && !isset($this->_connectingGatewayAddresses[$addr]) && isset($this->_gatewayAddresses[$addr])) {
+            $gateway_connection                    = new AsyncTcpConnection("GatewayProtocol://$addr");
+            $gateway_connection->remoteAddress     = $addr;
+            $gateway_connection->onConnect         = array($this, 'onConnectGateway');
+            $gateway_connection->onMessage         = array($this, 'onGatewayMessage');
+            $gateway_connection->onClose           = array($this, 'onGatewayClose');
+            $gateway_connection->onError           = array($this, 'onGatewayError');
+            $gateway_connection->maxSendBufferSize = $this->sendToGatewayBufferSize;
+            if (TcpConnection::$defaultMaxSendBufferSize == $gateway_connection->maxSendBufferSize) {
+                $gateway_connection->maxSendBufferSize = 50 * 1024 * 1024;
+            }
+            $gateway_data         = GatewayProtocol::$empty;
+            $gateway_data['cmd']  = GatewayProtocol::CMD_WORKER_CONNECT;
+            $gateway_data['body'] = json_encode(array(
+                'worker_key' =>"{$this->name}:{$this->id}", 
+                'secret_key' => $this->secretKey,
+            ));
+            $gateway_connection->send($gateway_data);
+            $gateway_connection->connect();
+            $this->_connectingGatewayAddresses[$addr] = $addr;
+        }
+        unset($this->_waitingConnectGatewayAddresses[$addr]);
+    }
+
+    /**
+     * 检查 gateway 的通信端口是否都已经连
+     * 如果有未连接的端口，则尝试连接
+     *
+     * @param array $addresses_list
+     */
+    public function checkGatewayConnections($addresses_list)
+    {
+        if (empty($addresses_list)) {
+            return;
+        }
+        foreach ($addresses_list as $addr) {
+            if (!isset($this->_waitingConnectGatewayAddresses[$addr])) {
+                $this->tryToConnectGateway($addr);
+            }
+        }
+    }
+
+    /**
+     * 当连接上 gateway 的通讯端口时触发
+     * 将连接 connection 对象保存起来
+     *
+     * @param TcpConnection $connection
+     * @return void
+     */
+    public function onConnectGateway($connection)
+    {
+        $this->gatewayConnections[$connection->remoteAddress] = $connection;
+        unset($this->_connectingGatewayAddresses[$connection->remoteAddress], $this->_waitingConnectGatewayAddresses[$connection->remoteAddress]);
+    }
+
+    /**
+     * 当与 gateway 的连接出现错误时触发
+     *
+     * @param TcpConnection $connection
+     * @param int           $error_no
+     * @param string        $error_msg
+     */
+    public function onGatewayError($connection, $error_no, $error_msg)
+    {
+        echo "GatewayConnection Error : $error_no ,$error_msg\n";
+    }
+
+    /**
+     * 获取所有 Gateway 内部通讯地址
+     *
+     * @return array
+     */
+    public function getAllGatewayAddresses()
+    {
+        return $this->_gatewayAddresses;
+    }
+
+    /**
+     * 业务超时回调
+     *
+     * @param int $signal
+     * @throws \Exception
+     */
+    public function timeoutHandler($signal)
+    {
+        switch ($signal) {
+            // 超时时钟
+            case SIGALRM:
+                // 超时异常
+                $e         = new \Exception("process_timeout", 506);
+                $trace_str = $e->getTraceAsString();
+                // 去掉第一行timeoutHandler的调用栈
+                $trace_str = $e->getMessage() . ":\n" . substr($trace_str, strpos($trace_str, "\n") + 1) . "\n";
+                // 开发者没有设置超时处理函数，或者超时处理函数返回空则执行退出
+                if (!$this->processTimeoutHandler || !call_user_func($this->processTimeoutHandler, $trace_str, $e)) {
+                    Worker::stopAll();
+                }
+                break;
+        }
+    }
+}

app/gateway/vendor/workerman/gateway-worker/src/Lib/Context.php

@@ -0,0 +1,136 @@
+<?php
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author    walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @link      http://www.workerman.net/
+ * @license   http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+namespace GatewayWorker\Lib;
+
+use Exception;
+
+/**
+ * 上下文 包含当前用户 uid， 内部通信 local_ip local_port socket_id，以及客户端 client_ip client_port
+ */
+class Context
+{
+    /**
+     * 内部通讯 id
+     *
+     * @var string
+     */
+    public static $local_ip;
+
+    /**
+     * 内部通讯端口
+     *
+     * @var int
+     */
+    public static $local_port;
+
+    /**
+     * 客户端 ip
+     *
+     * @var string
+     */
+    public static $client_ip;
+
+    /**
+     * 客户端端口
+     *
+     * @var int
+     */
+    public static $client_port;
+
+    /**
+     * client_id
+     *
+     * @var string
+     */
+    public static $client_id;
+
+    /**
+     * 连接 connection->id
+     *
+     * @var int
+     */
+    public static $connection_id;
+    
+    /**
+     * 旧的session
+     * 
+     * @var string
+     */
+    public static $old_session;
+
+    /**
+     * 编码 session
+     *
+     * @param mixed $session_data
+     * @return string
+     */
+    public static function sessionEncode($session_data = '')
+    {
+        if ($session_data !== '') {
+            return serialize($session_data);
+        }
+        return '';
+    }
+
+    /**
+     * 解码 session
+     *
+     * @param string $session_buffer
+     * @return mixed
+     */
+    public static function sessionDecode($session_buffer)
+    {
+        return unserialize($session_buffer);
+    }
+
+    /**
+     * 清除上下文
+     *
+     * @return void
+     */
+    public static function clear()
+    {
+        self::$local_ip = self::$local_port = self::$client_ip = self::$client_port =
+        self::$client_id = self::$connection_id  = self::$old_session = null;
+    }
+
+    /**
+     * 通讯地址到 client_id 的转换
+     *
+     * @param int $local_ip
+     * @param int $local_port
+     * @param int $connection_id
+     * @return string
+     */
+    public static function addressToClientId($local_ip, $local_port, $connection_id)
+    {
+        return bin2hex(pack('NnN', $local_ip, $local_port, $connection_id));
+    }
+
+    /**
+     * client_id 到通讯地址的转换
+     *
+     * @param string $client_id
+     * @return array
+     * @throws Exception
+     */
+    public static function clientIdToAddress($client_id)
+    {
+        if (strlen($client_id) !== 20) {
+            echo new Exception("client_id $client_id is invalid");
+            return false;
+        }
+        return unpack('Nlocal_ip/nlocal_port/Nconnection_id', pack('H*', $client_id));
+    }
+}

app/gateway/vendor/workerman/gateway-worker/src/Lib/Db.php

@@ -0,0 +1,76 @@
+<?php
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author    walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @link      http://www.workerman.net/
+ * @license   http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+namespace GatewayWorker\Lib;
+
+use Config\Db as DbConfig;
+use Exception;
+
+/**
+ * 数据库类
+ */
+class Db
+{
+    /**
+     * 实例数组
+     *
+     * @var array
+     */
+    protected static $instance = array();
+
+    /**
+     * 获取实例
+     *
+     * @param string $config_name
+     * @return DbConnection
+     * @throws Exception
+     */
+    public static function instance($config_name)
+    {
+        if (!isset(DbConfig::$$config_name)) {
+            echo "\\Config\\Db::$config_name not set\n";
+            throw new Exception("\\Config\\Db::$config_name not set\n");
+        }
+
+        if (empty(self::$instance[$config_name])) {
+            $config                       = DbConfig::$$config_name;
+            self::$instance[$config_name] = new DbConnection($config['host'], $config['port'],
+                $config['user'], $config['password'], $config['dbname'],$config['charset']);
+        }
+        return self::$instance[$config_name];
+    }
+
+    /**
+     * 关闭数据库实例
+     *
+     * @param string $config_name
+     */
+    public static function close($config_name)
+    {
+        if (isset(self::$instance[$config_name])) {
+            self::$instance[$config_name]->closeConnection();
+            self::$instance[$config_name] = null;
+        }
+    }
+
+    /**
+     * 关闭所有数据库实例
+     */
+    public static function closeAll()
+    {
+        foreach (self::$instance as $connection) {
+            $connection->closeConnection();
+        }
+        self::$instance = array();
+    }
+}

app/gateway/vendor/workerman/gateway-worker/src/Protocols/GatewayProtocol.php

@@ -0,0 +1,216 @@
+<?php
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author    walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @link      http://www.workerman.net/
+ * @license   http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+namespace GatewayWorker\Protocols;
+
+/**
+ * Gateway 与 Worker 间通讯的二进制协议
+ *
+ * struct GatewayProtocol
+ * {
+ *     unsigned int        pack_len,
+ *     unsigned char       cmd,//命令字
+ *     unsigned int        local_ip,
+ *     unsigned short      local_port,
+ *     unsigned int        client_ip,
+ *     unsigned short      client_port,
+ *     unsigned int        connection_id,
+ *     unsigned char       flag,
+ *     unsigned short      gateway_port,
+ *     unsigned int        ext_len,
+ *     char[ext_len]       ext_data,
+ *     char[pack_length-HEAD_LEN] body//包体
+ * }
+ * NCNnNnNCnN
+ */
+class GatewayProtocol
+{
+    // 发给worker，gateway有一个新的连接
+    const CMD_ON_CONNECT = 1;
+
+    // 发给worker的，客户端有消息
+    const CMD_ON_MESSAGE = 3;
+
+    // 发给worker上的关闭链接事件
+    const CMD_ON_CLOSE = 4;
+
+    // 发给gateway的向单个用户发送数据
+    const CMD_SEND_TO_ONE = 5;
+
+    // 发给gateway的向所有用户发送数据
+    const CMD_SEND_TO_ALL = 6;
+
+    // 发给gateway的踢出用户
+    // 1、如果有待发消息，将在发送完后立即销毁用户连接
+    // 2、如果无待发消息，将立即销毁用户连接
+    const CMD_KICK = 7;
+
+    // 发给gateway的立即销毁用户连接
+    const CMD_DESTROY = 8;
+
+    // 发给gateway，通知用户session更新
+    const CMD_UPDATE_SESSION = 9;
+
+    // 获取在线状态
+    const CMD_GET_ALL_CLIENT_SESSIONS = 10;
+
+    // 判断是否在线
+    const CMD_IS_ONLINE = 11;
+
+    // client_id绑定到uid
+    const CMD_BIND_UID = 12;
+
+    // 解绑
+    const CMD_UNBIND_UID = 13;
+
+    // 向uid发送数据
+    const CMD_SEND_TO_UID = 14;
+
+    // 根据uid获取绑定的clientid
+    const CMD_GET_CLIENT_ID_BY_UID = 15;
+
+    // 加入组
+    const CMD_JOIN_GROUP = 20;
+
+    // 离开组
+    const CMD_LEAVE_GROUP = 21;
+
+    // 向组成员发消息
+    const CMD_SEND_TO_GROUP = 22;
+
+    // 获取组成员
+    const CMD_GET_CLIENT_SESSIONS_BY_GROUP = 23;
+
+    // 获取组在线连接数
+    const CMD_GET_CLIENT_COUNT_BY_GROUP = 24;
+
+    // 按照条件查找
+    const CMD_SELECT = 25;
+
+    // 获取在线的群组ID
+    const CMD_GET_GROUP_ID_LIST = 26;
+
+    // 取消分组
+    const CMD_UNGROUP = 27;
+
+    // worker连接gateway事件
+    const CMD_WORKER_CONNECT = 200;
+
+    // 心跳
+    const CMD_PING = 201;
+
+    // GatewayClient连接gateway事件
+    const CMD_GATEWAY_CLIENT_CONNECT = 202;
+
+    // 根据client_id获取session
+    const CMD_GET_SESSION_BY_CLIENT_ID = 203;
+
+    // 发给gateway，覆盖session
+    const CMD_SET_SESSION = 204;
+
+    // 当websocket握手时触发，只有websocket协议支持此命令字
+    const CMD_ON_WEBSOCKET_CONNECT = 205;
+
+    // 包体是标量
+    const FLAG_BODY_IS_SCALAR = 0x01;
+
+    // 通知gateway在send时不调用协议encode方法，在广播组播时提升性能
+    const FLAG_NOT_CALL_ENCODE = 0x02;
+
+    /**
+     * 包头长度
+     *
+     * @var int
+     */
+    const HEAD_LEN = 28;
+
+    public static $empty = array(
+        'cmd'           => 0,
+        'local_ip'      => 0,
+        'local_port'    => 0,
+        'client_ip'     => 0,
+        'client_port'   => 0,
+        'connection_id' => 0,
+        'flag'          => 0,
+        'gateway_port'  => 0,
+        'ext_data'      => '',
+        'body'          => '',
+    );
+
+    /**
+     * 返回包长度
+     *
+     * @param string $buffer
+     * @return int return current package length
+     */
+    public static function input($buffer)
+    {
+        if (strlen($buffer) < self::HEAD_LEN) {
+            return 0;
+        }
+
+        $data = unpack("Npack_len", $buffer);
+        return $data['pack_len'];
+    }
+
+    /**
+     * 获取整个包的 buffer
+     *
+     * @param mixed $data
+     * @return string
+     */
+    public static function encode($data)
+    {
+        $flag = (int)is_scalar($data['body']);
+        if (!$flag) {
+            $data['body'] = serialize($data['body']);
+        }
+        $data['flag'] |= $flag;
+        $ext_len      = strlen($data['ext_data']);
+        $package_len  = self::HEAD_LEN + $ext_len + strlen($data['body']);
+        return pack("NCNnNnNCnN", $package_len,
+            $data['cmd'], $data['local_ip'],
+            $data['local_port'], $data['client_ip'],
+            $data['client_port'], $data['connection_id'],
+            $data['flag'], $data['gateway_port'],
+            $ext_len) . $data['ext_data'] . $data['body'];
+    }
+
+    /**
+     * 从二进制数据转换为数组
+     *
+     * @param string $buffer
+     * @return array
+     */
+    public static function decode($buffer)
+    {
+        $data = unpack("Npack_len/Ccmd/Nlocal_ip/nlocal_port/Nclient_ip/nclient_port/Nconnection_id/Cflag/ngateway_port/Next_len",
+            $buffer);
+        if ($data['ext_len'] > 0) {
+            $data['ext_data'] = substr($buffer, self::HEAD_LEN, $data['ext_len']);
+            if ($data['flag'] & self::FLAG_BODY_IS_SCALAR) {
+                $data['body'] = substr($buffer, self::HEAD_LEN + $data['ext_len']);
+            } else {
+                $data['body'] = unserialize(substr($buffer, self::HEAD_LEN + $data['ext_len']));
+            }
+        } else {
+            $data['ext_data'] = '';
+            if ($data['flag'] & self::FLAG_BODY_IS_SCALAR) {
+                $data['body'] = substr($buffer, self::HEAD_LEN);
+            } else {
+                $data['body'] = unserialize(substr($buffer, self::HEAD_LEN));
+            }
+        }
+        return $data;
+    }
+}

app/gateway/vendor/workerman/gateway-worker/src/Register.php

@@ -0,0 +1,190 @@
+<?php
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author    walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @link      http://www.workerman.net/
+ * @license   http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+namespace GatewayWorker;
+
+use Workerman\Worker;
+use Workerman\Lib\Timer;
+
+/**
+ *
+ * 注册中心，用于注册 Gateway 和 BusinessWorker
+ *
+ * @author walkor<walkor@workerman.net>
+ *
+ */
+class Register extends Worker
+{
+    /**
+     * {@inheritdoc}
+     */
+    public $name = 'Register';
+
+    /**
+     * {@inheritdoc}
+     */
+    public $reloadable = false;
+    
+    /**
+     * 秘钥
+     * @var string
+     */
+    public $secretKey = '';
+
+    /**
+     * 所有 gateway 的连接
+     *
+     * @var array
+     */
+    protected $_gatewayConnections = array();
+
+    /**
+     * 所有 worker 的连接
+     *
+     * @var array
+     */
+    protected $_workerConnections = array();
+
+    /**
+     * 进程启动时间
+     *
+     * @var int
+     */
+    protected $_startTime = 0;
+
+    /**
+     * {@inheritdoc}
+     */
+    public function run()
+    {
+        // 设置 onMessage 连接回调
+        $this->onConnect = array($this, 'onConnect');
+
+        // 设置 onMessage 回调
+        $this->onMessage = array($this, 'onMessage');
+
+        // 设置 onClose 回调
+        $this->onClose = array($this, 'onClose');
+
+        // 记录进程启动的时间
+        $this->_startTime = time();
+        
+        // 强制使用text协议
+        $this->protocol = '\Workerman\Protocols\Text';
+        
+        // 运行父方法
+        parent::run();
+    }
+
+    /**
+     * 设置个定时器，将未及时发送验证的连接关闭
+     *
+     * @param \Workerman\Connection\ConnectionInterface $connection
+     * @return void
+     */
+    public function onConnect($connection)
+    {
+        $connection->timeout_timerid = Timer::add(10, function () use ($connection) {
+            Worker::log("Register auth timeout (".$connection->getRemoteIp()."). See http://doc2.workerman.net/register-auth-timeout.html");
+            $connection->close();
+        }, null, false);
+    }
+
+    /**
+     * 设置消息回调
+     *
+     * @param \Workerman\Connection\ConnectionInterface $connection
+     * @param string                                    $buffer
+     * @return void
+     */
+    public function onMessage($connection, $buffer)
+    {
+        // 删除定时器
+        Timer::del($connection->timeout_timerid);
+        $data       = @json_decode($buffer, true);
+        if (empty($data['event'])) {
+            $error = "Bad request for Register service. Request info(IP:".$connection->getRemoteIp().", Request Buffer:$buffer). See http://doc2.workerman.net/register-auth-timeout.html";
+            Worker::log($error);
+            return $connection->close($error);
+        }
+        $event      = $data['event'];
+        $secret_key = $data['secret_key'] ?? '';
+        // 开始验证
+        switch ($event) {
+            // 是 gateway 连接
+            case 'gateway_connect':
+                if (empty($data['address'])) {
+                    echo "address not found\n";
+                    return $connection->close();
+                }
+                if ($secret_key !== $this->secretKey) {
+                    Worker::log("Register: Key does not match ".var_export($secret_key, true)." !== ".var_export($this->secretKey, true));
+                    return $connection->close();
+                }
+                $this->_gatewayConnections[$connection->id] = $data['address'];
+                $this->broadcastAddresses();
+                break;
+            // 是 worker 连接
+            case 'worker_connect':
+                if ($secret_key !== $this->secretKey) {
+                    Worker::log("Register: Key does not match ".var_export($secret_key, true)." !== ".var_export($this->secretKey, true));
+                    return $connection->close();
+                }
+                $this->_workerConnections[$connection->id] = $connection;
+                $this->broadcastAddresses($connection);
+                break;
+            case 'ping':
+                break;
+            default:
+                Worker::log("Register unknown event:$event IP: ".$connection->getRemoteIp()." Buffer:$buffer. See http://doc2.workerman.net/register-auth-timeout.html");
+                $connection->close();
+        }
+    }
+
+    /**
+     * 连接关闭时
+     *
+     * @param \Workerman\Connection\ConnectionInterface $connection
+     */
+    public function onClose($connection)
+    {
+        if (isset($this->_gatewayConnections[$connection->id])) {
+            unset($this->_gatewayConnections[$connection->id]);
+            $this->broadcastAddresses();
+        }
+        if (isset($this->_workerConnections[$connection->id])) {
+            unset($this->_workerConnections[$connection->id]);
+        }
+    }
+
+    /**
+     * 向 BusinessWorker 广播 gateway 内部通讯地址
+     *
+     * @param \Workerman\Connection\ConnectionInterface $connection
+     */
+    public function broadcastAddresses($connection = null)
+    {
+        $data   = array(
+            'event'     => 'broadcast_addresses',
+            'addresses' => array_unique(array_values($this->_gatewayConnections)),
+        );
+        $buffer = json_encode($data);
+        if ($connection) {
+            $connection->send($buffer);
+            return;
+        }
+        foreach ($this->_workerConnections as $con) {
+            $con->send($buffer);
+        }
+    }
+}

app/gateway/vendor/workerman/mysql/README.md

@@ -0,0 +1,78 @@
+# Workerman\Mysql\Connection
+
+Long-living MySQL connection for daemon.
+
+# Install
+```composer require workerman/mysql```
+
+# Usage
+```php
+$db = new Workerman\MySQL\Connection($mysql_host, $mysql_port, $user, $password, $db_bname);
+
+// Get all rows.
+$db1->select('ID,Sex')->from('Persons')->where('sex= :sex')->bindValues(array('sex'=>'M'))->query();
+// Equivalent to.
+$db1->select('ID,Sex')->from('Persons')->where("sex='F'")->query();
+// Equivalent to.
+$db->query("SELECT ID,Sex FROM `Persons` WHERE sex='M'");
+
+
+// Get one row.
+$db->select('ID,Sex')->from('Persons')->where('sex= :sex')->bindValues(array('sex'=>'M'))->row();
+// Equivalent to.
+$db->select('ID,Sex')->from('Persons')->where("sex= 'F' ")->row();
+// Equivalent to.
+$db->row("SELECT ID,Sex FROM `Persons` WHERE sex='M'");
+
+
+// Get a column.
+$db->select('ID')->from('Persons')->where('sex= :sex')->bindValues(array('sex'=>'M'))->column();
+// Equivalent to.
+$db->select('ID')->from('Persons')->where("sex= 'F' ")->column();
+// Equivalent to.
+$db->column("SELECT `ID` FROM `Persons` WHERE sex='M'");
+
+// Get single.
+$db->select('ID,Sex')->from('Persons')->where('sex= :sex')->bindValues(array('sex'=>'M'))->single();
+// Equivalent to.
+$db->select('ID,Sex')->from('Persons')->where("sex= 'F' ")->single();
+// Equivalent to.
+$db->single("SELECT ID,Sex FROM `Persons` WHERE sex='M'");
+
+// Complex query.
+$db->select('*')->from('table1')->innerJoin('table2','table1.uid = table2.uid')->where('age > :age')
+->groupBy(array('aid'))->having('foo="foo"')->orderByASC/*orderByDESC*/(array('did'))
+->limit(10)->offset(20)->bindValues(array('age' => 13));
+// Equivalent to.
+$db->query(SELECT * FROM `table1` INNER JOIN `table2` ON `table1`.`uid` = `table2`.`uid` WHERE age > 13
+GROUP BY aid HAVING foo="foo" ORDER BY did LIMIT 10 OFFSET 20“);
+
+// Insert.
+$insert_id = $db->insert('Persons')->cols(array(
+    'Firstname'=>'abc', 
+    'Lastname'=>'efg', 
+    'Sex'=>'M', 
+    'Age'=>13))->query();
+// Equivalent to.
+$insert_id = $db->query("INSERT INTO `Persons` ( `Firstname`,`Lastname`,`Sex`,`Age`) 
+VALUES ( 'abc', 'efg', 'M', 13)");
+
+// Updagte.
+$row_count = $db->update('Persons')->cols(array('sex'))->where('ID=1')
+->bindValue('sex', 'F')->query();
+// Equivalent to.
+$row_count = $db->update('Persons')->cols(array('sex'=>'F'))->where('ID=1')->query();
+// Equivalent to.
+$row_count = $db->query("UPDATE `Persons` SET `sex` = 'F' WHERE ID=1");
+
+// Delete.
+$row_count = $db->delete('Persons')->where('ID=9')->query();
+// Equivalent to.
+$row_count = $db->query("DELETE FROM `Persons` WHERE ID=9");
+
+// Transaction.
+$db1->beginTrans();
+....
+$db1->commitTrans(); // or $db1->rollBackTrans();
+
+```

app/gateway/vendor/workerman/mysql/composer.json

@@ -0,0 +1,16 @@
+{
+    "name"  : "workerman/mysql",
+    "type"  : "library",
+    "keywords": ["mysql", "pdo", "pdo_mysql"],
+    "homepage": "http://www.workerman.net",
+    "license" : "MIT",
+    "description": "Long-living MySQL connection for daemon.",
+    "require": {
+        "php": ">=5.3",
+        "ext-pdo": "*",
+        "ext-pdo_mysql": "*"
+    },
+    "autoload": {
+        "psr-4": {"Workerman\\MySQL\\": "./src"}
+    }
+}

app/gateway/vendor/workerman/workerman/.gitignore

@@ -0,0 +1,6 @@
+logs
+.buildpath
+.project
+.settings
+.idea
+.DS_Store

app/gateway/vendor/workerman/workerman/Autoloader.php

@@ -0,0 +1,69 @@
+<?php
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author    walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @link      http://www.workerman.net/
+ * @license   http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+namespace Workerman;
+
+/**
+ * Autoload.
+ */
+class Autoloader
+{
+    /**
+     * Autoload root path.
+     *
+     * @var string
+     */
+    protected static $_autoloadRootPath = '';
+
+    /**
+     * Set autoload root path.
+     *
+     * @param string $root_path
+     * @return void
+     */
+    public static function setRootPath($root_path)
+    {
+        self::$_autoloadRootPath = $root_path;
+    }
+
+    /**
+     * Load files by namespace.
+     *
+     * @param string $name
+     * @return boolean
+     */
+    public static function loadByNamespace($name)
+    {
+        $class_path = \str_replace('\\', \DIRECTORY_SEPARATOR, $name);
+        if (\strpos($name, 'Workerman\\') === 0) {
+            $class_file = __DIR__ . \substr($class_path, \strlen('Workerman')) . '.php';
+        } else {
+            if (self::$_autoloadRootPath) {
+                $class_file = self::$_autoloadRootPath . \DIRECTORY_SEPARATOR . $class_path . '.php';
+            }
+            if (empty($class_file) || !\is_file($class_file)) {
+                $class_file = __DIR__ . \DIRECTORY_SEPARATOR . '..' . \DIRECTORY_SEPARATOR . "$class_path.php";
+            }
+        }
+
+        if (\is_file($class_file)) {
+            require_once($class_file);
+            if (\class_exists($name, false)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+
+\spl_autoload_register('\Workerman\Autoloader::loadByNamespace');

app/gateway/vendor/workerman/workerman/Connection/AsyncTcpConnection.php

@@ -0,0 +1,377 @@
+<?php
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author    walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @link      http://www.workerman.net/
+ * @license   http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+namespace Workerman\Connection;
+
+use Workerman\Events\EventInterface;
+use Workerman\Lib\Timer;
+use Workerman\Worker;
+use \Exception;
+
+/**
+ * AsyncTcpConnection.
+ */
+class AsyncTcpConnection extends TcpConnection
+{
+    /**
+     * Emitted when socket connection is successfully established.
+     *
+     * @var callable|null
+     */
+    public $onConnect = null;
+
+    /**
+     * Transport layer protocol.
+     *
+     * @var string
+     */
+    public $transport = 'tcp';
+
+    /**
+     * Status.
+     *
+     * @var int
+     */
+    protected $_status = self::STATUS_INITIAL;
+
+    /**
+     * Remote host.
+     *
+     * @var string
+     */
+    protected $_remoteHost = '';
+
+    /**
+     * Remote port.
+     *
+     * @var int
+     */
+    protected $_remotePort = 80;
+
+    /**
+     * Connect start time.
+     *
+     * @var float
+     */
+    protected $_connectStartTime = 0;
+
+    /**
+     * Remote URI.
+     *
+     * @var string
+     */
+    protected $_remoteURI = '';
+
+    /**
+     * Context option.
+     *
+     * @var array
+     */
+    protected $_contextOption = null;
+
+    /**
+     * Reconnect timer.
+     *
+     * @var int
+     */
+    protected $_reconnectTimer = null;
+
+
+    /**
+     * PHP built-in protocols.
+     *
+     * @var array
+     */
+    protected static $_builtinTransports = array(
+        'tcp'   => 'tcp',
+        'udp'   => 'udp',
+        'unix'  => 'unix',
+        'ssl'   => 'ssl',
+        'sslv2' => 'sslv2',
+        'sslv3' => 'sslv3',
+        'tls'   => 'tls'
+    );
+
+    /**
+     * Construct.
+     *
+     * @param string $remote_address
+     * @param array $context_option
+     * @throws Exception
+     */
+    public function __construct($remote_address, array $context_option = array())
+    {
+        $address_info = \parse_url($remote_address);
+        if (!$address_info) {
+            list($scheme, $this->_remoteAddress) = \explode(':', $remote_address, 2);
+            if (!$this->_remoteAddress) {
+                Worker::safeEcho(new \Exception('bad remote_address'));
+            }
+        } else {
+            if (!isset($address_info['port'])) {
+                $address_info['port'] = 0;
+            }
+            if (!isset($address_info['path'])) {
+                $address_info['path'] = '/';
+            }
+            if (!isset($address_info['query'])) {
+                $address_info['query'] = '';
+            } else {
+                $address_info['query'] = '?' . $address_info['query'];
+            }
+            $this->_remoteAddress = "{$address_info['host']}:{$address_info['port']}";
+            $this->_remoteHost    = $address_info['host'];
+            $this->_remotePort    = $address_info['port'];
+            $this->_remoteURI     = "{$address_info['path']}{$address_info['query']}";
+            $scheme               = isset($address_info['scheme']) ? $address_info['scheme'] : 'tcp';
+        }
+
+        $this->id = $this->_id = self::$_idRecorder++;
+        if(\PHP_INT_MAX === self::$_idRecorder){
+            self::$_idRecorder = 0;
+        }
+        // Check application layer protocol class.
+        if (!isset(self::$_builtinTransports[$scheme])) {
+            $scheme         = \ucfirst($scheme);
+            $this->protocol = '\\Protocols\\' . $scheme;
+            if (!\class_exists($this->protocol)) {
+                $this->protocol = "\\Workerman\\Protocols\\$scheme";
+                if (!\class_exists($this->protocol)) {
+                    throw new Exception("class \\Protocols\\$scheme not exist");
+                }
+            }
+        } else {
+            $this->transport = self::$_builtinTransports[$scheme];
+        }
+
+        // For statistics.
+        ++self::$statistics['connection_count'];
+        $this->maxSendBufferSize         = self::$defaultMaxSendBufferSize;
+        $this->maxPackageSize            = self::$defaultMaxPackageSize;
+        $this->_contextOption            = $context_option;
+        static::$connections[$this->_id] = $this;
+    }
+
+    /**
+     * Do connect.
+     *
+     * @return void
+     */
+    public function connect()
+    {
+        if ($this->_status !== self::STATUS_INITIAL && $this->_status !== self::STATUS_CLOSING &&
+            $this->_status !== self::STATUS_CLOSED) {
+            return;
+        }
+        $this->_status           = self::STATUS_CONNECTING;
+        $this->_connectStartTime = \microtime(true);
+        if ($this->transport !== 'unix') {
+            if (!$this->_remotePort) {
+                $this->_remotePort = $this->transport === 'ssl' ? 443 : 80;
+                $this->_remoteAddress = $this->_remoteHost.':'.$this->_remotePort;
+            }
+            // Open socket connection asynchronously.
+            if ($this->_contextOption) {
+                $context = \stream_context_create($this->_contextOption);
+                $this->_socket = \stream_socket_client("tcp://{$this->_remoteHost}:{$this->_remotePort}",
+                    $errno, $errstr, 0, \STREAM_CLIENT_ASYNC_CONNECT, $context);
+            } else {
+                $this->_socket = \stream_socket_client("tcp://{$this->_remoteHost}:{$this->_remotePort}",
+                    $errno, $errstr, 0, \STREAM_CLIENT_ASYNC_CONNECT);
+            }
+        } else {
+            $this->_socket = \stream_socket_client("{$this->transport}://{$this->_remoteAddress}", $errno, $errstr, 0,
+                \STREAM_CLIENT_ASYNC_CONNECT);
+        }
+        // If failed attempt to emit onError callback.
+        if (!$this->_socket || !\is_resource($this->_socket)) {
+            $this->emitError(\WORKERMAN_CONNECT_FAIL, $errstr);
+            if ($this->_status === self::STATUS_CLOSING) {
+                $this->destroy();
+            }
+            if ($this->_status === self::STATUS_CLOSED) {
+                $this->onConnect = null;
+            }
+            return;
+        }
+        // Add socket to global event loop waiting connection is successfully established or faild.
+        Worker::$globalEvent->add($this->_socket, EventInterface::EV_WRITE, array($this, 'checkConnection'));
+        // For windows.
+        if(\DIRECTORY_SEPARATOR === '\\') {
+            Worker::$globalEvent->add($this->_socket, EventInterface::EV_EXCEPT, array($this, 'checkConnection'));
+        }
+    }
+
+    /**
+     * Reconnect.
+     *
+     * @param int $after
+     * @return void
+     */
+    public function reconnect($after = 0)
+    {
+        $this->_status                   = self::STATUS_INITIAL;
+        static::$connections[$this->_id] = $this;
+        if ($this->_reconnectTimer) {
+            Timer::del($this->_reconnectTimer);
+        }
+        if ($after > 0) {
+            $this->_reconnectTimer = Timer::add($after, array($this, 'connect'), null, false);
+            return;
+        }
+        $this->connect();
+    }
+
+    /**
+     * CancelReconnect.
+     */
+    public function cancelReconnect()
+    {
+        if ($this->_reconnectTimer) {
+            Timer::del($this->_reconnectTimer);
+        }
+    }
+
+    /**
+     * Get remote address.
+     *
+     * @return string
+     */
+    public function getRemoteHost()
+    {
+        return $this->_remoteHost;
+    }
+
+    /**
+     * Get remote URI.
+     *
+     * @return string
+     */
+    public function getRemoteURI()
+    {
+        return $this->_remoteURI;
+    }
+
+    /**
+     * Try to emit onError callback.
+     *
+     * @param int    $code
+     * @param string $msg
+     * @return void
+     */
+    protected function emitError($code, $msg)
+    {
+        $this->_status = self::STATUS_CLOSING;
+        if ($this->onError) {
+            try {
+                \call_user_func($this->onError, $this, $code, $msg);
+            } catch (\Exception $e) {
+                Worker::log($e);
+                exit(250);
+            } catch (\Error $e) {
+                Worker::log($e);
+                exit(250);
+            }
+        }
+    }
+
+    /**
+     * Check connection is successfully established or faild.
+     *
+     * @param resource $socket
+     * @return void
+     */
+    public function checkConnection()
+    {
+        // Remove EV_EXPECT for windows.
+        if(\DIRECTORY_SEPARATOR === '\\') {
+            Worker::$globalEvent->del($this->_socket, EventInterface::EV_EXCEPT);
+        }
+
+        // Remove write listener.
+        Worker::$globalEvent->del($this->_socket, EventInterface::EV_WRITE);
+
+        if ($this->_status !== self::STATUS_CONNECTING) {
+            return;
+        }
+
+        // Check socket state.
+        if ($address = \stream_socket_get_name($this->_socket, true)) {
+            // Nonblocking.
+            \stream_set_blocking($this->_socket, false);
+            // Compatible with hhvm
+            if (\function_exists('stream_set_read_buffer')) {
+                \stream_set_read_buffer($this->_socket, 0);
+            }
+            // Try to open keepalive for tcp and disable Nagle algorithm.
+            if (\function_exists('socket_import_stream') && $this->transport === 'tcp') {
+                $raw_socket = \socket_import_stream($this->_socket);
+                \socket_set_option($raw_socket, \SOL_SOCKET, \SO_KEEPALIVE, 1);
+                \socket_set_option($raw_socket, \SOL_TCP, \TCP_NODELAY, 1);
+            }
+
+            // SSL handshake.
+            if ($this->transport === 'ssl') {
+                $this->_sslHandshakeCompleted = $this->doSslHandshake($this->_socket);
+                if ($this->_sslHandshakeCompleted === false) {
+                    return;
+                }
+            } else {
+                // There are some data waiting to send.
+                if ($this->_sendBuffer) {
+                    Worker::$globalEvent->add($this->_socket, EventInterface::EV_WRITE, array($this, 'baseWrite'));
+                }
+            }
+
+            // Register a listener waiting read event.
+            Worker::$globalEvent->add($this->_socket, EventInterface::EV_READ, array($this, 'baseRead'));
+
+            $this->_status                = self::STATUS_ESTABLISHED;
+            $this->_remoteAddress         = $address;
+
+            // Try to emit onConnect callback.
+            if ($this->onConnect) {
+                try {
+                    \call_user_func($this->onConnect, $this);
+                } catch (\Exception $e) {
+                    Worker::log($e);
+                    exit(250);
+                } catch (\Error $e) {
+                    Worker::log($e);
+                    exit(250);
+                }
+            }
+            // Try to emit protocol::onConnect
+            if (\method_exists($this->protocol, 'onConnect')) {
+                try {
+                    \call_user_func(array($this->protocol, 'onConnect'), $this);
+                } catch (\Exception $e) {
+                    Worker::log($e);
+                    exit(250);
+                } catch (\Error $e) {
+                    Worker::log($e);
+                    exit(250);
+                }
+            }
+        } else {
+            // Connection failed.
+            $this->emitError(\WORKERMAN_CONNECT_FAIL, 'connect ' . $this->_remoteAddress . ' fail after ' . round(\microtime(true) - $this->_connectStartTime, 4) . ' seconds');
+            if ($this->_status === self::STATUS_CLOSING) {
+                $this->destroy();
+            }
+            if ($this->_status === self::STATUS_CLOSED) {
+                $this->onConnect = null;
+            }
+        }
+    }
+}

app/gateway/vendor/workerman/workerman/Connection/AsyncUdpConnection.php

@@ -0,0 +1,209 @@
+<?php
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author    walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @link      http://www.workerman.net/
+ * @license   http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+namespace Workerman\Connection;
+
+use Workerman\Events\EventInterface;
+use Workerman\Worker;
+use \Exception;
+
+/**
+ * AsyncTcpConnection.
+ */
+class AsyncUdpConnection extends UdpConnection
+{
+    /**
+     * Emitted when socket connection is successfully established.
+     *
+     * @var callable
+     */
+    public $onConnect = null;
+
+    /**
+     * Emitted when socket connection closed.
+     *
+     * @var callable
+     */
+    public $onClose = null;
+
+    /**
+     * Connected or not.
+     *
+     * @var bool
+     */
+    protected $connected = false;
+
+    /**
+     * Context option.
+     *
+     * @var array
+     */
+    protected $_contextOption = null;
+
+    /**
+     * Construct.
+     *
+     * @param string $remote_address
+     * @throws Exception
+     */
+    public function __construct($remote_address, $context_option = null)
+    {
+        // Get the application layer communication protocol and listening address.
+        list($scheme, $address) = \explode(':', $remote_address, 2);
+        // Check application layer protocol class.
+        if ($scheme !== 'udp') {
+            $scheme         = \ucfirst($scheme);
+            $this->protocol = '\\Protocols\\' . $scheme;
+            if (!\class_exists($this->protocol)) {
+                $this->protocol = "\\Workerman\\Protocols\\$scheme";
+                if (!\class_exists($this->protocol)) {
+                    throw new Exception("class \\Protocols\\$scheme not exist");
+                }
+            }
+        }
+        
+        $this->_remoteAddress = \substr($address, 2);
+        $this->_contextOption = $context_option;
+    }
+    
+    /**
+     * For udp package.
+     *
+     * @param resource $socket
+     * @return bool
+     */
+    public function baseRead($socket)
+    {
+        $recv_buffer = \stream_socket_recvfrom($socket, Worker::MAX_UDP_PACKAGE_SIZE, 0, $remote_address);
+        if (false === $recv_buffer || empty($remote_address)) {
+            return false;
+        }
+        
+        if ($this->onMessage) {
+            if ($this->protocol) {
+                $parser      = $this->protocol;
+                $recv_buffer = $parser::decode($recv_buffer, $this);
+            }
+            ++ConnectionInterface::$statistics['total_request'];
+            try {
+                \call_user_func($this->onMessage, $this, $recv_buffer);
+            } catch (\Exception $e) {
+                Worker::log($e);
+                exit(250);
+            } catch (\Error $e) {
+                Worker::log($e);
+                exit(250);
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Sends data on the connection.
+     *
+     * @param string $send_buffer
+     * @param bool   $raw
+     * @return void|boolean
+     */
+    public function send($send_buffer, $raw = false)
+    {
+        if (false === $raw && $this->protocol) {
+            $parser      = $this->protocol;
+            $send_buffer = $parser::encode($send_buffer, $this);
+            if ($send_buffer === '') {
+                return;
+            }
+        }
+        if ($this->connected === false) {
+            $this->connect();
+        }
+        return \strlen($send_buffer) === \stream_socket_sendto($this->_socket, $send_buffer, 0);
+    }
+    
+    
+    /**
+     * Close connection.
+     *
+     * @param mixed $data
+     * @param bool $raw
+     *
+     * @return bool
+     */
+    public function close($data = null, $raw = false)
+    {
+        if ($data !== null) {
+            $this->send($data, $raw);
+        }
+        Worker::$globalEvent->del($this->_socket, EventInterface::EV_READ);
+        \fclose($this->_socket);
+        $this->connected = false;
+        // Try to emit onClose callback.
+        if ($this->onClose) {
+            try {
+                \call_user_func($this->onClose, $this);
+            } catch (\Exception $e) {
+                Worker::log($e);
+                exit(250);
+            } catch (\Error $e) {
+                Worker::log($e);
+                exit(250);
+            }
+        }
+        $this->onConnect = $this->onMessage = $this->onClose = null;
+        return true;
+    }
+
+    /**
+     * Connect.
+     *
+     * @return void
+     */
+    public function connect()
+    {
+        if ($this->connected === true) {
+            return;
+        }
+        if ($this->_contextOption) {
+            $context = \stream_context_create($this->_contextOption);
+            $this->_socket = \stream_socket_client("udp://{$this->_remoteAddress}", $errno, $errmsg,
+                30, \STREAM_CLIENT_CONNECT, $context);
+        } else {
+            $this->_socket = \stream_socket_client("udp://{$this->_remoteAddress}", $errno, $errmsg);
+        }
+
+        if (!$this->_socket) {
+            Worker::safeEcho(new \Exception($errmsg));
+            return;
+        }
+        
+        \stream_set_blocking($this->_socket, false);
+        
+        if ($this->onMessage) {
+            Worker::$globalEvent->add($this->_socket, EventInterface::EV_READ, array($this, 'baseRead'));
+        }
+        $this->connected = true;
+        // Try to emit onConnect callback.
+        if ($this->onConnect) {
+            try {
+                \call_user_func($this->onConnect, $this);
+            } catch (\Exception $e) {
+                Worker::log($e);
+                exit(250);
+            } catch (\Error $e) {
+                Worker::log($e);
+                exit(250);
+            }
+        }
+    }
+
+}

app/gateway/vendor/workerman/workerman/Connection/ConnectionInterface.php

@@ -0,0 +1,125 @@
+<?php
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author    walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @link      http://www.workerman.net/
+ * @license   http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+namespace Workerman\Connection;
+
+/**
+ * ConnectionInterface.
+ */
+abstract class  ConnectionInterface
+{
+    /**
+     * Statistics for status command.
+     *
+     * @var array
+     */
+    public static $statistics = array(
+        'connection_count' => 0,
+        'total_request'    => 0,
+        'throw_exception'  => 0,
+        'send_fail'        => 0,
+    );
+
+    /**
+     * Emitted when data is received.
+     *
+     * @var callable
+     */
+    public $onMessage = null;
+
+    /**
+     * Emitted when the other end of the socket sends a FIN packet.
+     *
+     * @var callable
+     */
+    public $onClose = null;
+
+    /**
+     * Emitted when an error occurs with connection.
+     *
+     * @var callable
+     */
+    public $onError = null;
+
+    /**
+     * Sends data on the connection.
+     *
+     * @param mixed $send_buffer
+     * @return void|boolean
+     */
+    abstract public function send($send_buffer);
+
+    /**
+     * Get remote IP.
+     *
+     * @return string
+     */
+    abstract public function getRemoteIp();
+
+    /**
+     * Get remote port.
+     *
+     * @return int
+     */
+    abstract public function getRemotePort();
+
+    /**
+     * Get remote address.
+     *
+     * @return string
+     */
+    abstract public function getRemoteAddress();
+
+    /**
+     * Get local IP.
+     *
+     * @return string
+     */
+    abstract public function getLocalIp();
+
+    /**
+     * Get local port.
+     *
+     * @return int
+     */
+    abstract public function getLocalPort();
+
+    /**
+     * Get local address.
+     *
+     * @return string
+     */
+    abstract public function getLocalAddress();
+
+    /**
+     * Is ipv4.
+     *
+     * @return bool
+     */
+    abstract public function isIPv4();
+
+    /**
+     * Is ipv6.
+     *
+     * @return bool
+     */
+    abstract public function isIPv6();
+
+    /**
+     * Close connection.
+     *
+     * @param $data
+     * @return void
+     */
+    abstract public function close($data = null);
+}

app/gateway/vendor/workerman/workerman/Connection/UdpConnection.php

@@ -0,0 +1,191 @@
+<?php
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author    walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @link      http://www.workerman.net/
+ * @license   http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+namespace Workerman\Connection;
+
+/**
+ * UdpConnection.
+ */
+class UdpConnection extends ConnectionInterface
+{
+    /**
+     * Application layer protocol.
+     * The format is like this Workerman\\Protocols\\Http.
+     *
+     * @var \Workerman\Protocols\ProtocolInterface
+     */
+    public $protocol = null;
+
+    /**
+     * Udp socket.
+     *
+     * @var resource
+     */
+    protected $_socket = null;
+
+    /**
+     * Remote address.
+     *
+     * @var string
+     */
+    protected $_remoteAddress = '';
+
+    /**
+     * Construct.
+     *
+     * @param resource $socket
+     * @param string   $remote_address
+     */
+    public function __construct($socket, $remote_address)
+    {
+        $this->_socket        = $socket;
+        $this->_remoteAddress = $remote_address;
+    }
+
+    /**
+     * Sends data on the connection.
+     *
+     * @param string $send_buffer
+     * @param bool   $raw
+     * @return void|boolean
+     */
+    public function send($send_buffer, $raw = false)
+    {
+        if (false === $raw && $this->protocol) {
+            $parser      = $this->protocol;
+            $send_buffer = $parser::encode($send_buffer, $this);
+            if ($send_buffer === '') {
+                return;
+            }
+        }
+        return \strlen($send_buffer) === \stream_socket_sendto($this->_socket, $send_buffer, 0, $this->_remoteAddress);
+    }
+
+    /**
+     * Get remote IP.
+     *
+     * @return string
+     */
+    public function getRemoteIp()
+    {
+        $pos = \strrpos($this->_remoteAddress, ':');
+        if ($pos) {
+            return \trim(\substr($this->_remoteAddress, 0, $pos), '[]');
+        }
+        return '';
+    }
+
+    /**
+     * Get remote port.
+     *
+     * @return int
+     */
+    public function getRemotePort()
+    {
+        if ($this->_remoteAddress) {
+            return (int)\substr(\strrchr($this->_remoteAddress, ':'), 1);
+        }
+        return 0;
+    }
+
+    /**
+     * Get remote address.
+     *
+     * @return string
+     */
+    public function getRemoteAddress()
+    {
+        return $this->_remoteAddress;
+    }
+
+    /**
+     * Get local IP.
+     *
+     * @return string
+     */
+    public function getLocalIp()
+    {
+        $address = $this->getLocalAddress();
+        $pos = \strrpos($address, ':');
+        if (!$pos) {
+            return '';
+        }
+        return \substr($address, 0, $pos);
+    }
+
+    /**
+     * Get local port.
+     *
+     * @return int
+     */
+    public function getLocalPort()
+    {
+        $address = $this->getLocalAddress();
+        $pos = \strrpos($address, ':');
+        if (!$pos) {
+            return 0;
+        }
+        return (int)\substr(\strrchr($address, ':'), 1);
+    }
+
+    /**
+     * Get local address.
+     *
+     * @return string
+     */
+    public function getLocalAddress()
+    {
+        return (string)@\stream_socket_get_name($this->_socket, false);
+    }
+
+    /**
+     * Is ipv4.
+     *
+     * @return bool.
+     */
+    public function isIpV4()
+    {
+        if ($this->transport === 'unix') {
+            return false;
+        }
+        return \strpos($this->getRemoteIp(), ':') === false;
+    }
+
+    /**
+     * Is ipv6.
+     *
+     * @return bool.
+     */
+    public function isIpV6()
+    {
+        if ($this->transport === 'unix') {
+            return false;
+        }
+        return \strpos($this->getRemoteIp(), ':') !== false;
+    }
+
+    /**
+     * Close connection.
+     *
+     * @param mixed $data
+     * @param bool  $raw
+     * @return bool
+     */
+    public function close($data = null, $raw = false)
+    {
+        if ($data !== null) {
+            $this->send($data, $raw);
+        }
+        return true;
+    }
+}

app/gateway/vendor/workerman/workerman/Events/Ev.php

@@ -0,0 +1,195 @@
+<?php
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author  有个鬼<42765633@qq.com>
+ * @link    http://www.workerman.net/
+ * @license http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+namespace Workerman\Events;
+
+use Workerman\Worker;
+use \EvWatcher;
+
+/**
+ * ev eventloop
+ */
+class Ev implements EventInterface
+{
+    /**
+     * All listeners for read/write event.
+     *
+     * @var array
+     */
+    protected $_allEvents = array();
+
+    /**
+     * Event listeners of signal.
+     *
+     * @var array
+     */
+    protected $_eventSignal = array();
+
+    /**
+     * All timer event listeners.
+     * [func, args, event, flag, time_interval]
+     *
+     * @var array
+     */
+    protected $_eventTimer = array();
+
+    /**
+     * Timer id.
+     *
+     * @var int
+     */
+    protected static $_timerId = 1;
+
+    /**
+     * Add a timer.
+     * {@inheritdoc}
+     */
+    public function add($fd, $flag, $func, $args = null)
+    {
+        $callback = function ($event, $socket) use ($fd, $func) {
+            try {
+                \call_user_func($func, $fd);
+            } catch (\Exception $e) {
+                Worker::log($e);
+                exit(250);
+            } catch (\Error $e) {
+                Worker::log($e);
+                exit(250);
+            }
+        };
+        switch ($flag) {
+            case self::EV_SIGNAL:
+                $event                   = new \EvSignal($fd, $callback);
+                $this->_eventSignal[$fd] = $event;
+                return true;
+            case self::EV_TIMER:
+            case self::EV_TIMER_ONCE:
+                $repeat                             = $flag === self::EV_TIMER_ONCE ? 0 : $fd;
+                $param                              = array($func, (array)$args, $flag, $fd, self::$_timerId);
+                $event                              = new \EvTimer($fd, $repeat, array($this, 'timerCallback'), $param);
+                $this->_eventTimer[self::$_timerId] = $event;
+                return self::$_timerId++;
+            default :
+                $fd_key                           = (int)$fd;
+                $real_flag                        = $flag === self::EV_READ ? \Ev::READ : \Ev::WRITE;
+                $event                            = new \EvIo($fd, $real_flag, $callback);
+                $this->_allEvents[$fd_key][$flag] = $event;
+                return true;
+        }
+
+    }
+
+    /**
+     * Remove a timer.
+     * {@inheritdoc}
+     */
+    public function del($fd, $flag)
+    {
+        switch ($flag) {
+            case self::EV_READ:
+            case self::EV_WRITE:
+                $fd_key = (int)$fd;
+                if (isset($this->_allEvents[$fd_key][$flag])) {
+                    $this->_allEvents[$fd_key][$flag]->stop();
+                    unset($this->_allEvents[$fd_key][$flag]);
+                }
+                if (empty($this->_allEvents[$fd_key])) {
+                    unset($this->_allEvents[$fd_key]);
+                }
+                break;
+            case  self::EV_SIGNAL:
+                $fd_key = (int)$fd;
+                if (isset($this->_eventSignal[$fd_key])) {
+                    $this->_eventSignal[$fd_key]->stop();
+                    unset($this->_eventSignal[$fd_key]);
+                }
+                break;
+            case self::EV_TIMER:
+            case self::EV_TIMER_ONCE:
+                if (isset($this->_eventTimer[$fd])) {
+                    $this->_eventTimer[$fd]->stop();
+                    unset($this->_eventTimer[$fd]);
+                }
+                break;
+        }
+        return true;
+    }
+
+    /**
+     * Timer callback.
+     *
+     * @param EvWatcher $event
+     */
+    public function timerCallback(EvWatcher $event)
+    {
+        $param    = $event->data;
+        $timer_id = $param[4];
+        if ($param[2] === self::EV_TIMER_ONCE) {
+            $this->_eventTimer[$timer_id]->stop();
+            unset($this->_eventTimer[$timer_id]);
+        }
+        try {
+            \call_user_func_array($param[0], $param[1]);
+        } catch (\Exception $e) {
+            Worker::log($e);
+            exit(250);
+        } catch (\Error $e) {
+            Worker::log($e);
+            exit(250);
+        }
+    }
+
+    /**
+     * Remove all timers.
+     *
+     * @return void
+     */
+    public function clearAllTimer()
+    {
+        foreach ($this->_eventTimer as $event) {
+            $event->stop();
+        }
+        $this->_eventTimer = array();
+    }
+
+    /**
+     * Main loop.
+     *
+     * @see EventInterface::loop()
+     */
+    public function loop()
+    {
+        \Ev::run();
+    }
+
+    /**
+     * Destroy loop.
+     *
+     * @return void
+     */
+    public function destroy()
+    {
+        foreach ($this->_allEvents as $event) {
+            $event->stop();
+        }
+    }
+
+    /**
+     * Get timer count.
+     *
+     * @return integer
+     */
+    public function getTimerCount()
+    {
+        return \count($this->_eventTimer);
+    }
+}

app/gateway/vendor/workerman/workerman/Events/Event.php

@@ -0,0 +1,219 @@
+<?php 
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author    有个鬼<42765633@qq.com>
+ * @copyright 有个鬼<42765633@qq.com>
+ * @link      http://www.workerman.net/
+ * @license   http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+namespace Workerman\Events;
+
+use Workerman\Worker;
+
+/**
+ * libevent eventloop
+ */
+class Event implements EventInterface
+{
+    /**
+     * Event base.
+     * @var object
+     */
+    protected $_eventBase = null;
+    
+    /**
+     * All listeners for read/write event.
+     * @var array
+     */
+    protected $_allEvents = array();
+    
+    /**
+     * Event listeners of signal.
+     * @var array
+     */
+    protected $_eventSignal = array();
+    
+    /**
+     * All timer event listeners.
+     * [func, args, event, flag, time_interval]
+     * @var array
+     */
+    protected $_eventTimer = array();
+
+    /**
+     * Timer id.
+     * @var int
+     */
+    protected static $_timerId = 1;
+    
+    /**
+     * construct
+     * @return void
+     */
+    public function __construct()
+    {
+        if (\class_exists('\\\\EventBase', false)) {
+            $class_name = '\\\\EventBase';
+        } else {
+            $class_name = '\EventBase';
+        }
+        $this->_eventBase = new $class_name();
+    }
+   
+    /**
+     * @see EventInterface::add()
+     */
+    public function add($fd, $flag, $func, $args=array())
+    {
+        if (\class_exists('\\\\Event', false)) {
+            $class_name = '\\\\Event';
+        } else {
+            $class_name = '\Event';
+        }
+        switch ($flag) {
+            case self::EV_SIGNAL:
+
+                $fd_key = (int)$fd;
+                $event = $class_name::signal($this->_eventBase, $fd, $func);
+                if (!$event||!$event->add()) {
+                    return false;
+                }
+                $this->_eventSignal[$fd_key] = $event;
+                return true;
+
+            case self::EV_TIMER:
+            case self::EV_TIMER_ONCE:
+
+                $param = array($func, (array)$args, $flag, $fd, self::$_timerId);
+                $event = new $class_name($this->_eventBase, -1, $class_name::TIMEOUT|$class_name::PERSIST, array($this, "timerCallback"), $param);
+                if (!$event||!$event->addTimer($fd)) {
+                    return false;
+                }
+                $this->_eventTimer[self::$_timerId] = $event;
+                return self::$_timerId++;
+                
+            default :
+                $fd_key = (int)$fd;
+                $real_flag = $flag === self::EV_READ ? $class_name::READ | $class_name::PERSIST : $class_name::WRITE | $class_name::PERSIST;
+                $event = new $class_name($this->_eventBase, $fd, $real_flag, $func, $fd);
+                if (!$event||!$event->add()) {
+                    return false;
+                }
+                $this->_allEvents[$fd_key][$flag] = $event;
+                return true;
+        }
+    }
+    
+    /**
+     * @see Events\EventInterface::del()
+     */
+    public function del($fd, $flag)
+    {
+        switch ($flag) {
+
+            case self::EV_READ:
+            case self::EV_WRITE:
+
+                $fd_key = (int)$fd;
+                if (isset($this->_allEvents[$fd_key][$flag])) {
+                    $this->_allEvents[$fd_key][$flag]->del();
+                    unset($this->_allEvents[$fd_key][$flag]);
+                }
+                if (empty($this->_allEvents[$fd_key])) {
+                    unset($this->_allEvents[$fd_key]);
+                }
+                break;
+
+            case  self::EV_SIGNAL:
+                $fd_key = (int)$fd;
+                if (isset($this->_eventSignal[$fd_key])) {
+                    $this->_eventSignal[$fd_key]->del();
+                    unset($this->_eventSignal[$fd_key]);
+                }
+                break;
+
+            case self::EV_TIMER:
+            case self::EV_TIMER_ONCE:
+                if (isset($this->_eventTimer[$fd])) {
+                    $this->_eventTimer[$fd]->del();
+                    unset($this->_eventTimer[$fd]);
+                }
+                break;
+        }
+        return true;
+    }
+    
+    /**
+     * Timer callback.
+     * @param null $fd
+     * @param int $what
+     * @param int $timer_id
+     */
+    public function timerCallback($fd, $what, $param)
+    {
+        $timer_id = $param[4];
+        
+        if ($param[2] === self::EV_TIMER_ONCE) {
+            $this->_eventTimer[$timer_id]->del();
+            unset($this->_eventTimer[$timer_id]);
+        }
+
+        try {
+            \call_user_func_array($param[0], $param[1]);
+        } catch (\Exception $e) {
+            Worker::log($e);
+            exit(250);
+        } catch (\Error $e) {
+            Worker::log($e);
+            exit(250);
+        }
+    }
+    
+    /**
+     * @see Events\EventInterface::clearAllTimer() 
+     * @return void
+     */
+    public function clearAllTimer()
+    {
+        foreach ($this->_eventTimer as $event) {
+            $event->del();
+        }
+        $this->_eventTimer = array();
+    }
+     
+
+    /**
+     * @see EventInterface::loop()
+     */
+    public function loop()
+    {
+        $this->_eventBase->loop();
+    }
+
+    /**
+     * Destroy loop.
+     *
+     * @return void
+     */
+    public function destroy()
+    {
+        foreach ($this->_eventSignal as $event) {
+            $event->del();
+        }
+    }
+
+    /**
+     * Get timer count.
+     *
+     * @return integer
+     */
+    public function getTimerCount()
+    {
+        return \count($this->_eventTimer);
+    }
+}

app/gateway/vendor/workerman/workerman/Events/EventInterface.php

@@ -0,0 +1,107 @@
+<?php
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author    walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @link      http://www.workerman.net/
+ * @license   http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+namespace Workerman\Events;
+
+interface EventInterface
+{
+    /**
+     * Read event.
+     *
+     * @var int
+     */
+    const EV_READ = 1;
+
+    /**
+     * Write event.
+     *
+     * @var int
+     */
+    const EV_WRITE = 2;
+
+    /**
+     * Except event
+     *
+     * @var int
+     */
+    const EV_EXCEPT = 3;
+
+    /**
+     * Signal event.
+     *
+     * @var int
+     */
+    const EV_SIGNAL = 4;
+
+    /**
+     * Timer event.
+     *
+     * @var int
+     */
+    const EV_TIMER = 8;
+
+    /**
+     * Timer once event.
+     *
+     * @var int
+     */
+    const EV_TIMER_ONCE = 16;
+
+    /**
+     * Add event listener to event loop.
+     *
+     * @param mixed    $fd
+     * @param int      $flag
+     * @param callable $func
+     * @param mixed    $args
+     * @return bool
+     */
+    public function add($fd, $flag, $func, $args = null);
+
+    /**
+     * Remove event listener from event loop.
+     *
+     * @param mixed $fd
+     * @param int   $flag
+     * @return bool
+     */
+    public function del($fd, $flag);
+
+    /**
+     * Remove all timers.
+     *
+     * @return void
+     */
+    public function clearAllTimer();
+
+    /**
+     * Main loop.
+     *
+     * @return void
+     */
+    public function loop();
+
+    /**
+     * Destroy loop.
+     *
+     * @return mixed
+     */
+    public function destroy();
+
+    /**
+     * Get Timer count.
+     *
+     * @return mixed
+     */
+    public function getTimerCount();
+}

app/gateway/vendor/workerman/workerman/Events/Libevent.php

@@ -0,0 +1,227 @@
+<?php
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author    walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @link      http://www.workerman.net/
+ * @license   http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+namespace Workerman\Events;
+
+use Workerman\Worker;
+
+/**
+ * libevent eventloop
+ */
+class Libevent implements EventInterface
+{
+    /**
+     * Event base.
+     *
+     * @var resource
+     */
+    protected $_eventBase = null;
+
+    /**
+     * All listeners for read/write event.
+     *
+     * @var array
+     */
+    protected $_allEvents = array();
+
+    /**
+     * Event listeners of signal.
+     *
+     * @var array
+     */
+    protected $_eventSignal = array();
+
+    /**
+     * All timer event listeners.
+     * [func, args, event, flag, time_interval]
+     *
+     * @var array
+     */
+    protected $_eventTimer = array();
+
+    /**
+     * construct
+     */
+    public function __construct()
+    {
+        $this->_eventBase = \event_base_new();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function add($fd, $flag, $func, $args = array())
+    {
+        switch ($flag) {
+            case self::EV_SIGNAL:
+                $fd_key                      = (int)$fd;
+                $real_flag                   = \EV_SIGNAL | \EV_PERSIST;
+                $this->_eventSignal[$fd_key] = \event_new();
+                if (!\event_set($this->_eventSignal[$fd_key], $fd, $real_flag, $func, null)) {
+                    return false;
+                }
+                if (!\event_base_set($this->_eventSignal[$fd_key], $this->_eventBase)) {
+                    return false;
+                }
+                if (!\event_add($this->_eventSignal[$fd_key])) {
+                    return false;
+                }
+                return true;
+            case self::EV_TIMER:
+            case self::EV_TIMER_ONCE:
+                $event    = \event_new();
+                $timer_id = (int)$event;
+                if (!\event_set($event, 0, \EV_TIMEOUT, array($this, 'timerCallback'), $timer_id)) {
+                    return false;
+                }
+
+                if (!\event_base_set($event, $this->_eventBase)) {
+                    return false;
+                }
+
+                $time_interval = $fd * 1000000;
+                if (!\event_add($event, $time_interval)) {
+                    return false;
+                }
+                $this->_eventTimer[$timer_id] = array($func, (array)$args, $event, $flag, $time_interval);
+                return $timer_id;
+
+            default :
+                $fd_key    = (int)$fd;
+                $real_flag = $flag === self::EV_READ ? \EV_READ | \EV_PERSIST : \EV_WRITE | \EV_PERSIST;
+
+                $event = \event_new();
+
+                if (!\event_set($event, $fd, $real_flag, $func, null)) {
+                    return false;
+                }
+
+                if (!\event_base_set($event, $this->_eventBase)) {
+                    return false;
+                }
+
+                if (!\event_add($event)) {
+                    return false;
+                }
+
+                $this->_allEvents[$fd_key][$flag] = $event;
+
+                return true;
+        }
+
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function del($fd, $flag)
+    {
+        switch ($flag) {
+            case self::EV_READ:
+            case self::EV_WRITE:
+                $fd_key = (int)$fd;
+                if (isset($this->_allEvents[$fd_key][$flag])) {
+                    \event_del($this->_allEvents[$fd_key][$flag]);
+                    unset($this->_allEvents[$fd_key][$flag]);
+                }
+                if (empty($this->_allEvents[$fd_key])) {
+                    unset($this->_allEvents[$fd_key]);
+                }
+                break;
+            case  self::EV_SIGNAL:
+                $fd_key = (int)$fd;
+                if (isset($this->_eventSignal[$fd_key])) {
+                    \event_del($this->_eventSignal[$fd_key]);
+                    unset($this->_eventSignal[$fd_key]);
+                }
+                break;
+            case self::EV_TIMER:
+            case self::EV_TIMER_ONCE:
+                // 这里 fd 为timerid 
+                if (isset($this->_eventTimer[$fd])) {
+                    \event_del($this->_eventTimer[$fd][2]);
+                    unset($this->_eventTimer[$fd]);
+                }
+                break;
+        }
+        return true;
+    }
+
+    /**
+     * Timer callback.
+     *
+     * @param mixed $_null1
+     * @param int   $_null2
+     * @param mixed $timer_id
+     */
+    protected function timerCallback($_null1, $_null2, $timer_id)
+    {
+        if ($this->_eventTimer[$timer_id][3] === self::EV_TIMER) {
+            \event_add($this->_eventTimer[$timer_id][2], $this->_eventTimer[$timer_id][4]);
+        }
+        try {
+            \call_user_func_array($this->_eventTimer[$timer_id][0], $this->_eventTimer[$timer_id][1]);
+        } catch (\Exception $e) {
+            Worker::log($e);
+            exit(250);
+        } catch (\Error $e) {
+            Worker::log($e);
+            exit(250);
+        }
+        if (isset($this->_eventTimer[$timer_id]) && $this->_eventTimer[$timer_id][3] === self::EV_TIMER_ONCE) {
+            $this->del($timer_id, self::EV_TIMER_ONCE);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function clearAllTimer()
+    {
+        foreach ($this->_eventTimer as $task_data) {
+            \event_del($task_data[2]);
+        }
+        $this->_eventTimer = array();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function loop()
+    {
+        \event_base_loop($this->_eventBase);
+    }
+
+    /**
+     * Destroy loop.
+     *
+     * @return void
+     */
+    public function destroy()
+    {
+        foreach ($this->_eventSignal as $event) {
+            \event_del($event);
+        }
+    }
+
+    /**
+     * Get timer count.
+     *
+     * @return integer
+     */
+    public function getTimerCount()
+    {
+        return \count($this->_eventTimer);
+    }
+}
+

app/gateway/vendor/workerman/workerman/Events/React/Base.php

@@ -0,0 +1,264 @@
+<?php
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author    walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @link      http://www.workerman.net/
+ * @license   http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+namespace Workerman\Events\React;
+
+use Workerman\Events\EventInterface;
+use React\EventLoop\TimerInterface;
+use React\EventLoop\LoopInterface;
+
+/**
+ * Class StreamSelectLoop
+ * @package Workerman\Events\React
+ */
+class Base implements LoopInterface
+{
+    /**
+     * @var array
+     */
+    protected $_timerIdMap = array();
+
+    /**
+     * @var int
+     */
+    protected $_timerIdIndex = 0;
+
+    /**
+     * @var array
+     */
+    protected $_signalHandlerMap = array();
+
+    /**
+     * @var LoopInterface
+     */
+    protected $_eventLoop = null;
+
+    /**
+     * Base constructor.
+     */
+    public function __construct()
+    {
+        $this->_eventLoop = new \React\EventLoop\StreamSelectLoop();
+    }
+
+    /**
+     * Add event listener to event loop.
+     *
+     * @param $fd
+     * @param $flag
+     * @param $func
+     * @param array $args
+     * @return bool
+     */
+    public function add($fd, $flag, $func, array $args = array())
+    {
+        $args = (array)$args;
+        switch ($flag) {
+            case EventInterface::EV_READ:
+                return $this->addReadStream($fd, $func);
+            case EventInterface::EV_WRITE:
+                return $this->addWriteStream($fd, $func);
+            case EventInterface::EV_SIGNAL:
+                if (isset($this->_signalHandlerMap[$fd])) {
+                    $this->removeSignal($fd, $this->_signalHandlerMap[$fd]);
+                }
+                $this->_signalHandlerMap[$fd] = $func;
+                return $this->addSignal($fd, $func);
+            case EventInterface::EV_TIMER:
+                $timer_obj = $this->addPeriodicTimer($fd, function() use ($func, $args) {
+                    \call_user_func_array($func, $args);
+                });
+                $this->_timerIdMap[++$this->_timerIdIndex] = $timer_obj;
+                return $this->_timerIdIndex;
+            case EventInterface::EV_TIMER_ONCE:
+                $index = ++$this->_timerIdIndex;
+                $timer_obj = $this->addTimer($fd, function() use ($func, $args, $index) {
+                    $this->del($index,EventInterface::EV_TIMER_ONCE);
+                    \call_user_func_array($func, $args);
+                });
+                $this->_timerIdMap[$index] = $timer_obj;
+                return $this->_timerIdIndex;
+        }
+        return false;
+    }
+
+    /**
+     * Remove event listener from event loop.
+     *
+     * @param mixed $fd
+     * @param int   $flag
+     * @return bool
+     */
+    public function del($fd, $flag)
+    {
+        switch ($flag) {
+            case EventInterface::EV_READ:
+                return $this->removeReadStream($fd);
+            case EventInterface::EV_WRITE:
+                return $this->removeWriteStream($fd);
+            case EventInterface::EV_SIGNAL:
+                if (!isset($this->_eventLoop[$fd])) {
+                    return false;
+                }
+                $func = $this->_eventLoop[$fd];
+                unset($this->_eventLoop[$fd]);
+                return $this->removeSignal($fd, $func);
+
+            case EventInterface::EV_TIMER:
+            case EventInterface::EV_TIMER_ONCE:
+                if (isset($this->_timerIdMap[$fd])){
+                    $timer_obj = $this->_timerIdMap[$fd];
+                    unset($this->_timerIdMap[$fd]);
+                    $this->cancelTimer($timer_obj);
+                    return true;
+                }
+        }
+        return false;
+    }
+
+
+    /**
+     * Main loop.
+     *
+     * @return void
+     */
+    public function loop()
+    {
+        $this->run();
+    }
+
+
+    /**
+     * Destroy loop.
+     *
+     * @return void
+     */
+    public function destroy()
+    {
+
+    }
+
+    /**
+     * Get timer count.
+     *
+     * @return integer
+     */
+    public function getTimerCount()
+    {
+        return \count($this->_timerIdMap);
+    }
+
+    /**
+     * @param resource $stream
+     * @param callable $listener
+     */
+    public function addReadStream($stream, $listener)
+    {
+        return $this->_eventLoop->addReadStream($stream, $listener);
+    }
+
+    /**
+     * @param resource $stream
+     * @param callable $listener
+     */
+    public function addWriteStream($stream, $listener)
+    {
+        return $this->_eventLoop->addWriteStream($stream, $listener);
+    }
+
+    /**
+     * @param resource $stream
+     */
+    public function removeReadStream($stream)
+    {
+        return $this->_eventLoop->removeReadStream($stream);
+    }
+
+    /**
+     * @param resource $stream
+     */
+    public function removeWriteStream($stream)
+    {
+        return $this->_eventLoop->removeWriteStream($stream);
+    }
+
+    /**
+     * @param float|int $interval
+     * @param callable $callback
+     * @return \React\EventLoop\Timer\Timer|TimerInterface
+     */
+    public function addTimer($interval, $callback)
+    {
+        return $this->_eventLoop->addTimer($interval, $callback);
+    }
+
+    /**
+     * @param float|int $interval
+     * @param callable $callback
+     * @return \React\EventLoop\Timer\Timer|TimerInterface
+     */
+    public function addPeriodicTimer($interval, $callback)
+    {
+        return $this->_eventLoop->addPeriodicTimer($interval, $callback);
+    }
+
+    /**
+     * @param TimerInterface $timer
+     */
+    public function cancelTimer(TimerInterface $timer)
+    {
+        return $this->_eventLoop->cancelTimer($timer);
+    }
+
+    /**
+     * @param callable $listener
+     */
+    public function futureTick($listener)
+    {
+        return $this->_eventLoop->futureTick($listener);
+    }
+
+    /**
+     * @param int $signal
+     * @param callable $listener
+     */
+    public function addSignal($signal, $listener)
+    {
+        return $this->_eventLoop->addSignal($signal, $listener);
+    }
+
+    /**
+     * @param int $signal
+     * @param callable $listener
+     */
+    public function removeSignal($signal, $listener)
+    {
+        return $this->_eventLoop->removeSignal($signal, $listener);
+    }
+
+    /**
+     * Run.
+     */
+    public function run()
+    {
+        return $this->_eventLoop->run();
+    }
+
+    /**
+     * Stop.
+     */
+    public function stop()
+    {
+        return $this->_eventLoop->stop();
+    }
+}

app/gateway/vendor/workerman/workerman/Events/React/ExtEventLoop.php

@@ -0,0 +1,27 @@
+<?php
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author    walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @link      http://www.workerman.net/
+ * @license   http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+namespace Workerman\Events\React;
+
+/**
+ * Class ExtEventLoop
+ * @package Workerman\Events\React
+ */
+class ExtEventLoop extends Base
+{
+
+    public function __construct()
+    {
+        $this->_eventLoop = new \React\EventLoop\ExtEventLoop();
+    }
+}

app/gateway/vendor/workerman/workerman/Events/React/ExtLibEventLoop.php

@@ -0,0 +1,27 @@
+<?php
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author    walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @link      http://www.workerman.net/
+ * @license   http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+namespace Workerman\Events\React;
+use Workerman\Events\EventInterface;
+
+/**
+ * Class ExtLibEventLoop
+ * @package Workerman\Events\React
+ */
+class ExtLibEventLoop extends Base
+{
+    public function __construct()
+    {
+        $this->_eventLoop = new \React\EventLoop\ExtLibeventLoop();
+    }
+}

app/gateway/vendor/workerman/workerman/Events/React/StreamSelectLoop.php

@@ -0,0 +1,26 @@
+<?php
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author    walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @link      http://www.workerman.net/
+ * @license   http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+namespace Workerman\Events\React;
+
+/**
+ * Class StreamSelectLoop
+ * @package Workerman\Events\React
+ */
+class StreamSelectLoop extends Base
+{
+    public function __construct()
+    {
+        $this->_eventLoop = new \React\EventLoop\StreamSelectLoop();
+    }
+}

app/gateway/vendor/workerman/workerman/Events/Select.php

@@ -0,0 +1,339 @@
+<?php
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author    walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @link      http://www.workerman.net/
+ * @license   http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+namespace Workerman\Events;
+
+/**
+ * select eventloop
+ */
+class Select implements EventInterface
+{
+    /**
+     * All listeners for read/write event.
+     *
+     * @var array
+     */
+    public $_allEvents = array();
+
+    /**
+     * Event listeners of signal.
+     *
+     * @var array
+     */
+    public $_signalEvents = array();
+
+    /**
+     * Fds waiting for read event.
+     *
+     * @var array
+     */
+    protected $_readFds = array();
+
+    /**
+     * Fds waiting for write event.
+     *
+     * @var array
+     */
+    protected $_writeFds = array();
+
+    /**
+     * Fds waiting for except event.
+     *
+     * @var array
+     */
+    protected $_exceptFds = array();
+
+    /**
+     * Timer scheduler.
+     * {['data':timer_id, 'priority':run_timestamp], ..}
+     *
+     * @var \SplPriorityQueue
+     */
+    protected $_scheduler = null;
+
+    /**
+     * All timer event listeners.
+     * [[func, args, flag, timer_interval], ..]
+     *
+     * @var array
+     */
+    protected $_eventTimer = array();
+
+    /**
+     * Timer id.
+     *
+     * @var int
+     */
+    protected $_timerId = 1;
+
+    /**
+     * Select timeout.
+     *
+     * @var int
+     */
+    protected $_selectTimeout = 100000000;
+
+    /**
+     * Paired socket channels
+     *
+     * @var array
+     */
+    protected $channel = array();
+
+    /**
+     * Construct.
+     */
+    public function __construct()
+    {
+        // Init SplPriorityQueue.
+        $this->_scheduler = new \SplPriorityQueue();
+        $this->_scheduler->setExtractFlags(\SplPriorityQueue::EXTR_BOTH);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function add($fd, $flag, $func, $args = array())
+    {
+        switch ($flag) {
+            case self::EV_READ:
+            case self::EV_WRITE:
+                $count = $flag === self::EV_READ ? \count($this->_readFds) : \count($this->_writeFds);
+                if ($count >= 1024) {
+                    echo "Warning: system call select exceeded the maximum number of connections 1024, please install event/libevent extension for more connections.\n";
+                } else if (\DIRECTORY_SEPARATOR !== '/' && $count >= 256) {
+                    echo "Warning: system call select exceeded the maximum number of connections 256.\n";
+                }
+                $fd_key                           = (int)$fd;
+                $this->_allEvents[$fd_key][$flag] = array($func, $fd);
+                if ($flag === self::EV_READ) {
+                    $this->_readFds[$fd_key] = $fd;
+                } else {
+                    $this->_writeFds[$fd_key] = $fd;
+                }
+                break;
+            case self::EV_EXCEPT:
+                $fd_key = (int)$fd;
+                $this->_allEvents[$fd_key][$flag] = array($func, $fd);
+                $this->_exceptFds[$fd_key] = $fd;
+                break;
+            case self::EV_SIGNAL:
+                // Windows not support signal.
+                if(\DIRECTORY_SEPARATOR !== '/') {
+                    return false;
+                }
+                $fd_key                              = (int)$fd;
+                $this->_signalEvents[$fd_key][$flag] = array($func, $fd);
+                \pcntl_signal($fd, array($this, 'signalHandler'));
+                break;
+            case self::EV_TIMER:
+            case self::EV_TIMER_ONCE:
+                $timer_id = $this->_timerId++;
+                $run_time = \microtime(true) + $fd;
+                $this->_scheduler->insert($timer_id, -$run_time);
+                $this->_eventTimer[$timer_id] = array($func, (array)$args, $flag, $fd);
+                $select_timeout = ($run_time - \microtime(true)) * 1000000;
+                if( $this->_selectTimeout > $select_timeout ){ 
+                    $this->_selectTimeout = $select_timeout;   
+                }  
+                return $timer_id;
+        }
+
+        return true;
+    }
+
+    /**
+     * Signal handler.
+     *
+     * @param int $signal
+     */
+    public function signalHandler($signal)
+    {
+        \call_user_func_array($this->_signalEvents[$signal][self::EV_SIGNAL][0], array($signal));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function del($fd, $flag)
+    {
+        $fd_key = (int)$fd;
+        switch ($flag) {
+            case self::EV_READ:
+                unset($this->_allEvents[$fd_key][$flag], $this->_readFds[$fd_key]);
+                if (empty($this->_allEvents[$fd_key])) {
+                    unset($this->_allEvents[$fd_key]);
+                }
+                return true;
+            case self::EV_WRITE:
+                unset($this->_allEvents[$fd_key][$flag], $this->_writeFds[$fd_key]);
+                if (empty($this->_allEvents[$fd_key])) {
+                    unset($this->_allEvents[$fd_key]);
+                }
+                return true;
+            case self::EV_EXCEPT:
+                unset($this->_allEvents[$fd_key][$flag], $this->_exceptFds[$fd_key]);
+                if(empty($this->_allEvents[$fd_key]))
+                {
+                    unset($this->_allEvents[$fd_key]);
+                }
+                return true;
+            case self::EV_SIGNAL:
+                if(\DIRECTORY_SEPARATOR !== '/') {
+                    return false;
+                }
+                unset($this->_signalEvents[$fd_key]);
+                \pcntl_signal($fd, SIG_IGN);
+                break;
+            case self::EV_TIMER:
+            case self::EV_TIMER_ONCE;
+                unset($this->_eventTimer[$fd_key]);
+                return true;
+        }
+        return false;
+    }
+
+    /**
+     * Tick for timer.
+     *
+     * @return void
+     */
+    protected function tick()
+    {
+        while (!$this->_scheduler->isEmpty()) {
+            $scheduler_data       = $this->_scheduler->top();
+            $timer_id             = $scheduler_data['data'];
+            $next_run_time        = -$scheduler_data['priority'];
+            $time_now             = \microtime(true);
+            $this->_selectTimeout = ($next_run_time - $time_now) * 1000000;
+            if ($this->_selectTimeout <= 0) {
+                $this->_scheduler->extract();
+
+                if (!isset($this->_eventTimer[$timer_id])) {
+                    continue;
+                }
+
+                // [func, args, flag, timer_interval]
+                $task_data = $this->_eventTimer[$timer_id];
+                if ($task_data[2] === self::EV_TIMER) {
+                    $next_run_time = $time_now + $task_data[3];
+                    $this->_scheduler->insert($timer_id, -$next_run_time);
+                }
+                \call_user_func_array($task_data[0], $task_data[1]);
+                if (isset($this->_eventTimer[$timer_id]) && $task_data[2] === self::EV_TIMER_ONCE) {
+                    $this->del($timer_id, self::EV_TIMER_ONCE);
+                }
+                continue;
+            }
+            return;
+        }
+        $this->_selectTimeout = 100000000;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function clearAllTimer()
+    {
+        $this->_scheduler = new \SplPriorityQueue();
+        $this->_scheduler->setExtractFlags(\SplPriorityQueue::EXTR_BOTH);
+        $this->_eventTimer = array();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function loop()
+    {
+        while (1) {
+            if(\DIRECTORY_SEPARATOR === '/') {
+                // Calls signal handlers for pending signals
+                \pcntl_signal_dispatch();
+            }
+
+            $read  = $this->_readFds;
+            $write = $this->_writeFds;
+            $except = $this->_exceptFds;
+
+            if ($read || $write || $except) {
+                // Waiting read/write/signal/timeout events.
+                try {
+                    $ret = @stream_select($read, $write, $except, 0, $this->_selectTimeout);
+                } catch (\Exception $e) {} catch (\Error $e) {}
+
+            } else {
+                usleep($this->_selectTimeout);
+                $ret = false;
+            }
+
+
+            if (!$this->_scheduler->isEmpty()) {
+                $this->tick();
+            }
+
+            if (!$ret) {
+                continue;
+            }
+
+            if ($read) {
+                foreach ($read as $fd) {
+                    $fd_key = (int)$fd;
+                    if (isset($this->_allEvents[$fd_key][self::EV_READ])) {
+                        \call_user_func_array($this->_allEvents[$fd_key][self::EV_READ][0],
+                            array($this->_allEvents[$fd_key][self::EV_READ][1]));
+                    }
+                }
+            }
+
+            if ($write) {
+                foreach ($write as $fd) {
+                    $fd_key = (int)$fd;
+                    if (isset($this->_allEvents[$fd_key][self::EV_WRITE])) {
+                        \call_user_func_array($this->_allEvents[$fd_key][self::EV_WRITE][0],
+                            array($this->_allEvents[$fd_key][self::EV_WRITE][1]));
+                    }
+                }
+            }
+
+            if($except) {
+                foreach($except as $fd) {
+                    $fd_key = (int) $fd;
+                    if(isset($this->_allEvents[$fd_key][self::EV_EXCEPT])) {
+                        \call_user_func_array($this->_allEvents[$fd_key][self::EV_EXCEPT][0],
+                            array($this->_allEvents[$fd_key][self::EV_EXCEPT][1]));
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Destroy loop.
+     *
+     * @return void
+     */
+    public function destroy()
+    {
+
+    }
+
+    /**
+     * Get timer count.
+     *
+     * @return integer
+     */
+    public function getTimerCount()
+    {
+        return \count($this->_eventTimer);
+    }
+}

app/gateway/vendor/workerman/workerman/Events/Swoole.php

@@ -0,0 +1,221 @@
+<?php
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author    Ares<aresrr#qq.com>
+ * @link      http://www.workerman.net/
+ * @link      https://github.com/ares333/Workerman
+ * @license   http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+namespace Workerman\Events;
+
+use Swoole\Event;
+use Swoole\Timer;
+
+class Swoole implements EventInterface
+{
+
+    protected $_timer = array();
+
+    protected $_timerOnceMap = array();
+
+    protected $mapId = 0;
+
+    protected $_fd = array();
+
+    // milisecond
+    public static $signalDispatchInterval = 200;
+
+    protected $_hasSignal = false;
+
+    /**
+     *
+     * {@inheritdoc}
+     *
+     * @see \Workerman\Events\EventInterface::add()
+     */
+    public function add($fd, $flag, $func, $args = null)
+    {
+        if (! isset($args)) {
+            $args = array();
+        }
+        switch ($flag) {
+            case self::EV_SIGNAL:
+                $res = \pcntl_signal($fd, $func, false);
+                if (! $this->_hasSignal && $res) {
+                    Timer::tick(static::$signalDispatchInterval,
+                        function () {
+                            \pcntl_signal_dispatch();
+                        });
+                    $this->_hasSignal = true;
+                }
+                return $res;
+            case self::EV_TIMER:
+            case self::EV_TIMER_ONCE:
+                $method = self::EV_TIMER === $flag ? 'tick' : 'after';
+                if ($this->mapId > \PHP_INT_MAX) {
+                    $this->mapId = 0;
+                }
+                $mapId = $this->mapId++;
+                $timer_id = Timer::$method($fd * 1000,
+                    function ($timer_id = null) use ($func, $args, $mapId) {
+                        \call_user_func_array($func, $args);
+                        // EV_TIMER_ONCE
+                        if (! isset($timer_id)) {
+                            // may be deleted in $func
+                            if (\array_key_exists($mapId, $this->_timerOnceMap)) {
+                                $timer_id = $this->_timerOnceMap[$mapId];
+                                unset($this->_timer[$timer_id],
+                                    $this->_timerOnceMap[$mapId]);
+                            }
+                        }
+                    });
+                if ($flag === self::EV_TIMER_ONCE) {
+                    $this->_timerOnceMap[$mapId] = $timer_id;
+                    $this->_timer[$timer_id] = $mapId;
+                } else {
+                    $this->_timer[$timer_id] = null;
+                }
+                return $timer_id;
+            case self::EV_READ:
+            case self::EV_WRITE:
+                $fd_key = (int) $fd;
+                if (! isset($this->_fd[$fd_key])) {
+                    if ($flag === self::EV_READ) {
+                        $res = Event::add($fd, $func, null, SWOOLE_EVENT_READ);
+                        $fd_type = SWOOLE_EVENT_READ;
+                    } else {
+                        $res = Event::add($fd, null, $func, SWOOLE_EVENT_WRITE);
+                        $fd_type = SWOOLE_EVENT_WRITE;
+                    }
+                    if ($res) {
+                        $this->_fd[$fd_key] = $fd_type;
+                    }
+                } else {
+                    $fd_val = $this->_fd[$fd_key];
+                    $res = true;
+                    if ($flag === self::EV_READ) {
+                        if (($fd_val & SWOOLE_EVENT_READ) !== SWOOLE_EVENT_READ) {
+                            $res = Event::set($fd, $func, null,
+                                SWOOLE_EVENT_READ | SWOOLE_EVENT_WRITE);
+                            $this->_fd[$fd_key] |= SWOOLE_EVENT_READ;
+                        }
+                    } else {
+                        if (($fd_val & SWOOLE_EVENT_WRITE) !== SWOOLE_EVENT_WRITE) {
+                            $res = Event::set($fd, null, $func,
+                                SWOOLE_EVENT_READ | SWOOLE_EVENT_WRITE);
+                            $this->_fd[$fd_key] |= SWOOLE_EVENT_WRITE;
+                        }
+                    }
+                }
+                return $res;
+        }
+    }
+
+    /**
+     *
+     * {@inheritdoc}
+     *
+     * @see \Workerman\Events\EventInterface::del()
+     */
+    public function del($fd, $flag)
+    {
+        switch ($flag) {
+            case self::EV_SIGNAL:
+                return \pcntl_signal($fd, SIG_IGN, false);
+            case self::EV_TIMER:
+            case self::EV_TIMER_ONCE:
+                // already remove in EV_TIMER_ONCE callback.
+                if (! \array_key_exists($fd, $this->_timer)) {
+                    return true;
+                }
+                $res = Timer::clear($fd);
+                if ($res) {
+                    $mapId = $this->_timer[$fd];
+                    if (isset($mapId)) {
+                        unset($this->_timerOnceMap[$mapId]);
+                    }
+                    unset($this->_timer[$fd]);
+                }
+                return $res;
+            case self::EV_READ:
+            case self::EV_WRITE:
+                $fd_key = (int) $fd;
+                if (isset($this->_fd[$fd_key])) {
+                    $fd_val = $this->_fd[$fd_key];
+                    if ($flag === self::EV_READ) {
+                        $flag_remove = ~ SWOOLE_EVENT_READ;
+                    } else {
+                        $flag_remove = ~ SWOOLE_EVENT_WRITE;
+                    }
+                    $fd_val &= $flag_remove;
+                    if (0 === $fd_val) {
+                        $res = Event::del($fd);
+                        if ($res) {
+                            unset($this->_fd[$fd_key]);
+                        }
+                    } else {
+                        $res = Event::set($fd, null, null, $fd_val);
+                        if ($res) {
+                            $this->_fd[$fd_key] = $fd_val;
+                        }
+                    }
+                } else {
+                    $res = true;
+                }
+                return $res;
+        }
+    }
+
+    /**
+     *
+     * {@inheritdoc}
+     *
+     * @see \Workerman\Events\EventInterface::clearAllTimer()
+     */
+    public function clearAllTimer()
+    {
+        foreach (array_keys($this->_timer) as $v) {
+            Timer::clear($v);
+        }
+        $this->_timer = array();
+        $this->_timerOnceMap = array();
+    }
+
+    /**
+     *
+     * {@inheritdoc}
+     *
+     * @see \Workerman\Events\EventInterface::loop()
+     */
+    public function loop()
+    {
+        Event::wait();
+    }
+
+    /**
+     *
+     * {@inheritdoc}
+     *
+     * @see \Workerman\Events\EventInterface::destroy()
+     */
+    public function destroy()
+    {
+        //Event::exit();
+    }
+
+    /**
+     *
+     * {@inheritdoc}
+     *
+     * @see \Workerman\Events\EventInterface::getTimerCount()
+     */
+    public function getTimerCount()
+    {
+        return \count($this->_timer);
+    }
+}

app/gateway/vendor/workerman/workerman/Lib/Constants.php

@@ -0,0 +1,48 @@
+<?php
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author    walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @license   http://www.opensource.org/licenses/mit-license.php MIT License
+ *
+ * @link      http://www.workerman.net/
+ */
+
+// Display errors.
+ini_set('display_errors', 'on');
+// Reporting all.
+error_reporting(E_ALL);
+// JIT is not stable, temporarily disabled.
+ini_set('pcre.jit', 0);
+
+// For onError callback.
+const WORKERMAN_CONNECT_FAIL = 1;
+// For onError callback.
+const WORKERMAN_SEND_FAIL = 2;
+
+// Define OS Type
+const OS_TYPE_LINUX   = 'linux';
+const OS_TYPE_WINDOWS = 'windows';
+
+// Compatible with php7
+if (!class_exists('Error')) {
+    class Error extends Exception
+    {
+    }
+}
+
+if (!interface_exists('SessionHandlerInterface')) {
+    interface SessionHandlerInterface {
+        public function close();
+        public function destroy($session_id);
+        public function gc($maxlifetime);
+        public function open($save_path ,$session_name);
+        public function read($session_id);
+        public function write($session_id , $session_data);
+    }
+}

app/gateway/vendor/workerman/workerman/Lib/Timer.php

@@ -0,0 +1,22 @@
+<?php
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author    walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @link      http://www.workerman.net/
+ * @license   http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+namespace Workerman\Lib;
+
+/**
+ * Do not use Workerman\Lib\Timer.
+ * Please use Workerman\Timer.
+ * This class is only used for compatibility with workerman 3.*
+ * @package Workerman\Lib
+ */
+class Timer extends \Workerman\Timer {}

app/gateway/vendor/workerman/workerman/Protocols/Frame.php

@@ -0,0 +1,61 @@
+<?php
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author    walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @link      http://www.workerman.net/
+ * @license   http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+namespace Workerman\Protocols;
+
+use Workerman\Connection\TcpConnection;
+
+/**
+ * Frame Protocol.
+ */
+class Frame
+{
+    /**
+     * Check the integrity of the package.
+     *
+     * @param string        $buffer
+     * @param TcpConnection $connection
+     * @return int
+     */
+    public static function input($buffer, TcpConnection $connection)
+    {
+        if (\strlen($buffer) < 4) {
+            return 0;
+        }
+        $unpack_data = \unpack('Ntotal_length', $buffer);
+        return $unpack_data['total_length'];
+    }
+
+    /**
+     * Decode.
+     *
+     * @param string $buffer
+     * @return string
+     */
+    public static function decode($buffer)
+    {
+        return \substr($buffer, 4);
+    }
+
+    /**
+     * Encode.
+     *
+     * @param string $buffer
+     * @return string
+     */
+    public static function encode($buffer)
+    {
+        $total_length = 4 + \strlen($buffer);
+        return \pack('N', $total_length) . $buffer;
+    }
+}

app/gateway/vendor/workerman/workerman/Protocols/Http.php

@@ -0,0 +1,326 @@
+<?php
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author    walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @link      http://www.workerman.net/
+ * @license   http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+namespace Workerman\Protocols;
+
+use Workerman\Connection\TcpConnection;
+use Workerman\Protocols\Http\Request;
+use Workerman\Protocols\Http\Response;
+use Workerman\Protocols\Websocket;
+use Workerman\Worker;
+
+/**
+ * Class Http.
+ * @package Workerman\Protocols
+ */
+class Http
+{
+    /**
+     * Request class name.
+     *
+     * @var string
+     */
+    protected static $_requestClass = 'Workerman\Protocols\Http\Request';
+
+    /**
+     * Session name.
+     *
+     * @var string
+     */
+    protected static $_sessionName = 'PHPSID';
+
+    /**
+     * Upload tmp dir.
+     *
+     * @var string
+     */
+    protected static $_uploadTmpDir = '';
+
+    /**
+     * Open cache.
+     *
+     * @var bool.
+     */
+    protected static $_enableCache = true;
+
+    /**
+     * Get or set session name.
+     *
+     * @param null $name
+     * @return string
+     */
+    public static function sessionName($name = null)
+    {
+        if ($name !== null && $name !== '') {
+            static::$_sessionName = (string)$name;
+        }
+        return static::$_sessionName;
+    }
+
+    /**
+     * Get or set the request class name.
+     *
+     * @param null $class_name
+     * @return string
+     */
+    public static function requestClass($class_name = null)
+    {
+        if ($class_name) {
+            static::$_requestClass = $class_name;
+        }
+        return static::$_requestClass;
+    }
+
+    /**
+     * Enable or disable Cache.
+     *
+     * @param $value
+     */
+    public static function enableCache($value)
+    {
+        static::$_enableCache = (bool)$value;
+    }
+
+    /**
+     * Check the integrity of the package.
+     *
+     * @param string $recv_buffer
+     * @param TcpConnection $connection
+     * @return int
+     */
+    public static function input($recv_buffer, TcpConnection $connection)
+    {
+        static $input = array();
+        if (!isset($recv_buffer[512]) && isset($input[$recv_buffer])) {
+            return $input[$recv_buffer];
+        }
+        $crlf_pos = \strpos($recv_buffer, "\r\n\r\n");
+        if (false === $crlf_pos) {
+            // Judge whether the package length exceeds the limit.
+            if ($recv_len = \strlen($recv_buffer) >= 16384) {
+                $connection->close("HTTP/1.1 413 Request Entity Too Large\r\n\r\n");
+                return 0;
+            }
+            return 0;
+        }
+
+        $head_len = $crlf_pos + 4;
+        $method = \strstr($recv_buffer, ' ', true);
+
+        if ($method === 'GET' || $method === 'OPTIONS' || $method === 'HEAD' || $method === 'DELETE') {
+            if (!isset($recv_buffer[512])) {
+                $input[$recv_buffer] = $head_len;
+                if (\count($input) > 512) {
+                    unset($input[key($input)]);
+                }
+            }
+            return $head_len;
+        } else if ($method !== 'POST' && $method !== 'PUT') {
+            $connection->close("HTTP/1.1 400 Bad Request\r\n\r\n", true);
+            return 0;
+        }
+
+        $header = \substr($recv_buffer, 0, $crlf_pos);
+        $length = false;
+        if ($pos = \strpos($header, "\r\nContent-Length: ")) {
+            $length = $head_len + (int)\substr($header, $pos + 18, 10);
+        } else if (\preg_match("/\r\ncontent-length: ?(\d+)/i", $header, $match)) {
+            $length = $head_len + $match[1];
+        }
+
+        if ($length !== false) {
+            if (!isset($recv_buffer[512])) {
+                $input[$recv_buffer] = $length;
+                if (\count($input) > 512) {
+                    unset($input[key($input)]);
+                }
+            }
+            return $length;
+        }
+
+        $connection->close("HTTP/1.1 400 Bad Request\r\n\r\n", true);
+        return 0;
+    }
+
+    /**
+     * Http decode.
+     *
+     * @param string $recv_buffer
+     * @param TcpConnection $connection
+     * @return \Workerman\Protocols\Http\Request
+     */
+    public static function decode($recv_buffer, TcpConnection $connection)
+    {
+        static $requests = array();
+        $cacheable = static::$_enableCache && !isset($recv_buffer[512]);
+        if (true === $cacheable && isset($requests[$recv_buffer])) {
+            $request = $requests[$recv_buffer];
+            $request->connection = $connection;
+            $connection->__request = $request;
+            $request->properties = array();
+            return $request;
+        }
+        $request = new static::$_requestClass($recv_buffer);
+        $request->connection = $connection;
+        $connection->__request = $request;
+        if (true === $cacheable) {
+            $requests[$recv_buffer] = $request;
+            if (\count($requests) > 512) {
+                unset($requests[key($requests)]);
+            }
+        }
+        return $request;
+    }
+
+    /**
+     * Http encode.
+     *
+     * @param string|Response $response
+     * @param TcpConnection $connection
+     * @return string
+     */
+    public static function encode($response, TcpConnection $connection)
+    {
+        if (isset($connection->__request)) {
+            $connection->__request->session = null;
+            $connection->__request->connection = null;
+            $connection->__request = null;
+        }
+        if (\is_scalar($response) || null === $response) {
+            $ext_header = '';
+            if (isset($connection->__header)) {
+                foreach ($connection->__header as $name => $value) {
+                    if (\is_array($value)) {
+                        foreach ($value as $item) {
+                            $ext_header = "$name: $item\r\n";
+                        }
+                    } else {
+                        $ext_header = "$name: $value\r\n";
+                    }
+                }
+                unset($connection->__header);
+            }
+            $body_len = \strlen($response);
+            return "HTTP/1.1 200 OK\r\nServer: workerman\r\n{$ext_header}Connection: keep-alive\r\nContent-Type: text/html;charset=utf-8\r\nContent-Length: $body_len\r\n\r\n$response";
+        }
+
+        if (isset($connection->__header)) {
+            $response->withHeaders($connection->__header);
+            unset($connection->__header);
+        }
+
+        if (isset($response->file)) {
+            $file = $response->file['file'];
+            $offset = $response->file['offset'];
+            $length = $response->file['length'];
+            $file_size = (int)\filesize($file);
+            $body_len = $length > 0 ? $length : $file_size - $offset;
+            $response->withHeaders(array(
+                'Content-Length' => $body_len,
+                'Accept-Ranges'  => 'bytes',
+            ));
+            if ($offset || $length) {
+                $offset_end = $offset + $body_len - 1;
+                $response->header('Content-Range', "bytes $offset-$offset_end/$file_size");
+            }
+            if ($body_len < 2 * 1024 * 1024) {
+                $connection->send((string)$response . file_get_contents($file, false, null, $offset, $body_len), true);
+                return '';
+            }
+            $handler = \fopen($file, 'r');
+            if (false === $handler) {
+                $connection->close(new Response(403, null, '403 Forbidden'));
+                return '';
+            }
+            $connection->send((string)$response, true);
+            static::sendStream($connection, $handler, $offset, $length);
+            return '';
+        }
+
+        return (string)$response;
+    }
+
+    /**
+     * Send remainder of a stream to client.
+     *
+     * @param TcpConnection $connection
+     * @param $handler
+     * @param $offset
+     * @param $length
+     */
+    protected static function sendStream(TcpConnection $connection, $handler, $offset = 0, $length = 0)
+    {
+        $connection->bufferFull = false;
+        if ($offset !== 0) {
+            \fseek($handler, $offset);
+        }
+        $offset_end = $offset + $length;
+        // Read file content from disk piece by piece and send to client.
+        $do_write = function () use ($connection, $handler, $length, $offset_end) {
+            // Send buffer not full.
+            while ($connection->bufferFull === false) {
+                // Read from disk.
+                $size = 1024 * 1024;
+                if ($length !== 0) {
+                    $tell = \ftell($handler);
+                    $remain_size = $offset_end - $tell;
+                    if ($remain_size <= 0) {
+                        fclose($handler);
+                        $connection->onBufferDrain = null;
+                        return;
+                    }
+                    $size = $remain_size > $size ? $size : $remain_size;
+                }
+
+                $buffer = \fread($handler, $size);
+                // Read eof.
+                if ($buffer === '' || $buffer === false) {
+                    fclose($handler);
+                    $connection->onBufferDrain = null;
+                    return;
+                }
+                $connection->send($buffer, true);
+            }
+        };
+        // Send buffer full.
+        $connection->onBufferFull = function ($connection) {
+            $connection->bufferFull = true;
+        };
+        // Send buffer drain.
+        $connection->onBufferDrain = function ($connection) use ($do_write) {
+            $connection->bufferFull = false;
+            $do_write();
+        };
+        $do_write();
+    }
+
+    /**
+     * Set or get uploadTmpDir.
+     *
+     * @return bool|string
+     */
+    public static function uploadTmpDir($dir = null)
+    {
+        if (null !== $dir) {
+            static::$_uploadTmpDir = $dir;
+        }
+        if (static::$_uploadTmpDir === '') {
+            if ($upload_tmp_dir = \ini_get('upload_tmp_dir')) {
+                static::$_uploadTmpDir = $upload_tmp_dir;
+            } else if ($upload_tmp_dir = \sys_get_temp_dir()) {
+                static::$_uploadTmpDir = $upload_tmp_dir;
+            }
+        }
+        return static::$_uploadTmpDir;
+    }
+}

app/gateway/vendor/workerman/workerman/Protocols/Http/Chunk.php

@@ -0,0 +1,48 @@
+<?php
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author    walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @link      http://www.workerman.net/
+ * @license   http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+namespace Workerman\Protocols\Http;
+
+
+/**
+ * Class Chunk
+ * @package Workerman\Protocols\Http
+ */
+class Chunk
+{
+    /**
+     * Chunk buffer.
+     *
+     * @var string
+     */
+    protected $_buffer = null;
+
+    /**
+     * Chunk constructor.
+     * @param $buffer
+     */
+    public function __construct($buffer)
+    {
+        $this->_buffer = $buffer;
+    }
+
+    /**
+     * __toString
+     *
+     * @return string
+     */
+    public function __toString()
+    {
+        return \dechex(\strlen($this->_buffer))."\r\n$this->_buffer\r\n";
+    }
+}

app/gateway/vendor/workerman/workerman/Protocols/Http/Request.php

@@ -0,0 +1,617 @@
+<?php
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author    walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @link      http://www.workerman.net/
+ * @license   http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+namespace Workerman\Protocols\Http;
+
+use Workerman\Connection\TcpConnection;
+use Workerman\Protocols\Http\Session;
+use Workerman\Protocols\Http;
+use Workerman\Worker;
+
+/**
+ * Class Request
+ * @package Workerman\Protocols\Http
+ */
+class Request
+{
+    /**
+     * Connection.
+     *
+     * @var TcpConnection
+     */
+    public $connection = null;
+
+    /**
+     * Session instance.
+     *
+     * @var Session
+     */
+    public $session = null;
+
+    /**
+     * Properties.
+     *
+     * @var array
+     */
+    public $properties = array();
+
+    /**
+     * Http buffer.
+     *
+     * @var string
+     */
+    protected $_buffer = null;
+
+    /**
+     * Request data.
+     *
+     * @var array
+     */
+    protected $_data = null;
+
+    /**
+     * Header cache.
+     *
+     * @var array
+     */
+    protected static $_headerCache = array();
+
+    /**
+     * Get cache.
+     *
+     * @var array
+     */
+    protected static $_getCache = array();
+
+    /**
+     * Post cache.
+     *
+     * @var array
+     */
+    protected static $_postCache = array();
+
+    /**
+     * Enable cache.
+     *
+     * @var bool
+     */
+    protected static $_enableCache = true;
+
+
+    /**
+     * Request constructor.
+     *
+     * @param $buffer
+     */
+    public function __construct($buffer)
+    {
+        $this->_buffer = $buffer;
+    }
+
+    /**
+     * $_GET.
+     *
+     * @param null $name
+     * @param null $default
+     * @return mixed|null
+     */
+    public function get($name = null, $default = null)
+    {
+        if (!isset($this->_data['get'])) {
+            $this->parseGet();
+        }
+        if (null === $name) {
+            return $this->_data['get'];
+        }
+        return isset($this->_data['get'][$name]) ? $this->_data['get'][$name] : $default;
+    }
+
+    /**
+     * $_POST.
+     *
+     * @param $name
+     * @param null $default
+     * @return mixed|null
+     */
+    public function post($name = null, $default = null)
+    {
+        if (!isset($this->_data['post'])) {
+            $this->parsePost();
+        }
+        if (null === $name) {
+            return $this->_data['post'];
+        }
+        return isset($this->_data['post'][$name]) ? $this->_data['post'][$name] : $default;
+    }
+
+    /**
+     * Get header item by name.
+     *
+     * @param null $name
+     * @param null $default
+     * @return string|null
+     */
+    public function header($name = null, $default = null)
+    {
+        if (!isset($this->_data['headers'])) {
+            $this->parseHeaders();
+        }
+        if (null === $name) {
+            return $this->_data['headers'];
+        }
+        $name = \strtolower($name);
+        return isset($this->_data['headers'][$name]) ? $this->_data['headers'][$name] : $default;
+    }
+
+    /**
+     * Get cookie item by name.
+     *
+     * @param null $name
+     * @param null $default
+     * @return string|null
+     */
+    public function cookie($name = null, $default = null)
+    {
+        if (!isset($this->_data['cookie'])) {
+            \parse_str(\str_replace('; ', '&', $this->header('cookie')), $this->_data['cookie']);
+        }
+        if ($name === null) {
+            return $this->_data['cookie'];
+        }
+        return isset($this->_data['cookie'][$name]) ? $this->_data['cookie'][$name] : $default;
+    }
+
+    /**
+     * Get upload files.
+     *
+     * @param null $name
+     * @return array|null
+     */
+    public function file($name = null)
+    {
+        if (!isset($this->_data['files'])) {
+            $this->parsePost();
+        }
+        if (null === $name) {
+            return $this->_data['files'];
+        }
+        return isset($this->_data['files'][$name]) ? $this->_data['files'][$name] : null;
+    }
+
+    /**
+     * Get method.
+     *
+     * @return string
+     */
+    public function method()
+    {
+        if (!isset($this->_data['method'])) {
+            $this->parseHeadFirstLine();
+        }
+        return $this->_data['method'];
+    }
+
+    /**
+     * Get http protocol version.
+     *
+     * @return string.
+     */
+    public function protocolVersion()
+    {
+        if (!isset($this->_data['protocolVersion'])) {
+            $this->parseProtocolVersion();
+        }
+        return $this->_data['protocolVersion'];
+    }
+
+    /**
+     * Get host.
+     *
+     * @param bool $without_port
+     * @return string
+     */
+    public function host($without_port = false)
+    {
+        $host = $this->header('host');
+        if ($without_port && $pos = \strpos($host, ':')) {
+            return \substr($host, 0, $pos);
+        }
+        return $host;
+    }
+
+    /**
+     * Get uri.
+     *
+     * @return mixed
+     */
+    public function uri()
+    {
+        if (!isset($this->_data['uri'])) {
+            $this->parseHeadFirstLine();
+        }
+        return $this->_data['uri'];
+    }
+
+    /**
+     * Get path.
+     *
+     * @return mixed
+     */
+    public function path()
+    {
+        if (!isset($this->_data['path'])) {
+            $this->_data['path'] = \parse_url($this->uri(), PHP_URL_PATH);
+        }
+        return $this->_data['path'];
+    }
+
+    /**
+     * Get query string.
+     *
+     * @return mixed
+     */
+    public function queryString()
+    {
+        if (!isset($this->_data['query_string'])) {
+            $this->_data['query_string'] = \parse_url($this->uri(), PHP_URL_QUERY);
+        }
+        return $this->_data['query_string'];
+    }
+
+    /**
+     * Get session.
+     *
+     * @return bool|\Workerman\Protocols\Http\Session
+     */
+    public function session()
+    {
+        if ($this->session === null) {
+            $session_id = $this->sessionId();
+            if ($session_id === false) {
+                return false;
+            }
+            $this->session = new Session($session_id);
+        }
+        return $this->session;
+    }
+
+    /**
+     * Get session id.
+     *
+     * @return bool|mixed
+     */
+    public function sessionId()
+    {
+        if (!isset($this->_data['sid'])) {
+            $session_name = Http::sessionName();
+            $sid = $this->cookie($session_name);
+            if ($sid === '' || $sid === null) {
+                if ($this->connection === null) {
+                    Worker::safeEcho('Request->session() fail, header already send');
+                    return false;
+                }
+                $sid = static::createSessionId();
+                $cookie_params = \session_get_cookie_params();
+                $this->connection->__header['Set-Cookie'] = array($session_name . '=' . $sid
+                    . (empty($cookie_params['domain']) ? '' : '; Domain=' . $cookie_params['domain'])
+                    . (empty($cookie_params['lifetime']) ? '' : '; Max-Age=' . ($cookie_params['lifetime'] + \time()))
+                    . (empty($cookie_params['path']) ? '' : '; Path=' . $cookie_params['path'])
+                    . (!$cookie_params['secure'] ? '' : '; Secure')
+                    . (!$cookie_params['httponly'] ? '' : '; HttpOnly'));
+            }
+            $this->_data['sid'] = $sid;
+        }
+        return $this->_data['sid'];
+    }
+
+    /**
+     * Get http raw head.
+     *
+     * @return string
+     */
+    public function rawHead()
+    {
+        if (!isset($this->_data['head'])) {
+            $this->_data['head'] = \strstr($this->_buffer, "\r\n\r\n", true);
+        }
+        return $this->_data['head'];
+    }
+
+    /**
+     * Get http raw body.
+     *
+     * @return string
+     */
+    public function rawBody()
+    {
+        return \substr($this->_buffer, \strpos($this->_buffer, "\r\n\r\n") + 4);
+    }
+
+    /**
+     * Get raw buffer.
+     *
+     * @return string
+     */
+    public function rawBuffer()
+    {
+        return $this->_buffer;
+    }
+
+    /**
+     * Enable or disable cache.
+     *
+     * @param $value
+     */
+    public static function enableCache($value)
+    {
+        static::$_enableCache = (bool)$value;
+    }
+
+    /**
+     * Parse first line of http header buffer.
+     *
+     * @return void
+     */
+    protected function parseHeadFirstLine()
+    {
+        $first_line = \strstr($this->_buffer, "\r\n", true);
+        $tmp = \explode(' ', $first_line, 3);
+        $this->_data['method'] = $tmp[0];
+        $this->_data['uri'] = isset($tmp[1]) ? $tmp[1] : '/';
+    }
+
+    /**
+     * Parse protocol version.
+     *
+     * @return void
+     */
+    protected function parseProtocolVersion()
+    {
+        $first_line = \strstr($this->_buffer, "\r\n", true);
+        $protoco_version = substr(\strstr($first_line, 'HTTP/'), 5);
+        $this->_data['protocolVersion'] = $protoco_version ? $protoco_version : '1.0';
+    }
+
+    /**
+     * Parse headers.
+     *
+     * @return void
+     */
+    protected function parseHeaders()
+    {
+        $this->_data['headers'] = array();
+        $raw_head = $this->rawHead();
+        $head_buffer = \substr($raw_head, \strpos($raw_head, "\r\n") + 2);
+        $cacheable = static::$_enableCache && !isset($head_buffer[2048]);
+        if ($cacheable && isset(static::$_headerCache[$head_buffer])) {
+            $this->_data['headers'] = static::$_headerCache[$head_buffer];
+            return;
+        }
+        $head_data = \explode("\r\n", $head_buffer);
+        foreach ($head_data as $content) {
+            if (false !== \strpos($content, ':')) {
+                list($key, $value) = \explode(':', $content, 2);
+                $this->_data['headers'][\strtolower($key)] = \ltrim($value);
+            } else {
+                $this->_data['headers'][\strtolower($content)] = '';
+            }
+        }
+        if ($cacheable) {
+            static::$_headerCache[$head_buffer] = $this->_data['headers'];
+            if (\count(static::$_headerCache) > 128) {
+                unset(static::$_headerCache[key(static::$_headerCache)]);
+            }
+        }
+    }
+
+    /**
+     * Parse head.
+     *
+     * @return void
+     */
+    protected function parseGet()
+    {
+        $query_string = $this->queryString();
+        $this->_data['get'] = array();
+        if ($query_string === '') {
+            return;
+        }
+        $cacheable = static::$_enableCache && !isset($query_string[1024]);
+        if ($cacheable && isset(static::$_getCache[$query_string])) {
+            $this->_data['get'] = static::$_getCache[$query_string];
+            return;
+        }
+        \parse_str($query_string, $this->_data['get']);
+        if ($cacheable) {
+            static::$_getCache[$query_string] = $this->_data['get'];
+            if (\count(static::$_getCache) > 256) {
+                unset(static::$_getCache[key(static::$_getCache)]);
+            }
+        }
+    }
+
+    /**
+     * Parse post.
+     *
+     * @return void
+     */
+    protected function parsePost()
+    {
+        $body_buffer = $this->rawBody();
+        $this->_data['post'] = $this->_data['files'] = array();
+        if ($body_buffer === '') {
+            return;
+        }
+        $cacheable = static::$_enableCache && !isset($body_buffer[1024]);
+        if ($cacheable && isset(static::$_postCache[$body_buffer])) {
+            $this->_data['post'] = static::$_postCache[$body_buffer];
+            return;
+        }
+        $content_type = $this->header('content-type');
+        if ($content_type !== null && \preg_match('/boundary="?(\S+)"?/', $content_type, $match)) {
+            $http_post_boundary = '--' . $match[1];
+            $this->parseUploadFiles($http_post_boundary);
+            return;
+        }
+        \parse_str($body_buffer, $this->_data['post']);
+        if ($cacheable) {
+            static::$_postCache[$body_buffer] = $this->_data['post'];
+            if (\count(static::$_postCache) > 256) {
+                unset(static::$_postCache[key(static::$_postCache)]);
+            }
+        }
+    }
+
+    /**
+     * Parse upload files.
+     *
+     * @param $http_post_boundary
+     * @return void
+     */
+    protected function parseUploadFiles($http_post_boundary)
+    {
+        $http_body = $this->rawBody();
+        $http_body = \substr($http_body, 0, \strlen($http_body) - (\strlen($http_post_boundary) + 4));
+        $boundary_data_array = \explode($http_post_boundary . "\r\n", $http_body);
+        if ($boundary_data_array[0] === '') {
+            unset($boundary_data_array[0]);
+        }
+        $key = -1;
+        $files = array();
+        foreach ($boundary_data_array as $boundary_data_buffer) {
+            list($boundary_header_buffer, $boundary_value) = \explode("\r\n\r\n", $boundary_data_buffer, 2);
+            // Remove \r\n from the end of buffer.
+            $boundary_value = \substr($boundary_value, 0, -2);
+            $key++;
+            foreach (\explode("\r\n", $boundary_header_buffer) as $item) {
+                list($header_key, $header_value) = \explode(": ", $item);
+                $header_key = \strtolower($header_key);
+                switch ($header_key) {
+                    case "content-disposition":
+                        // Is file data.
+                        if (\preg_match('/name="(.*?)"; filename="(.*?)"$/i', $header_value, $match)) {
+                            $error = 0;
+                            $tmp_file = '';
+                            $size = \strlen($boundary_value);
+                            $tmp_upload_dir = HTTP::uploadTmpDir();
+                            if (!$tmp_upload_dir) {
+                                $error = UPLOAD_ERR_NO_TMP_DIR;
+                            } else {
+                                $tmp_file = \tempnam($tmp_upload_dir, 'workerman.upload.');
+                                if ($tmp_file === false || !\file_put_contents($tmp_file, $boundary_value)) {
+                                    $error = UPLOAD_ERR_CANT_WRITE;
+                                }
+                            }
+                            // Parse upload files.
+                            $files[$key] = array(
+                                'key' => $match[1],
+                                'name' => $match[2],
+                                'tmp_name' => $tmp_file,
+                                'size' => $size,
+                                'error' => $error
+                            );
+                            break;
+                        } // Is post field.
+                        else {
+                            // Parse $_POST.
+                            if (\preg_match('/name="(.*?)"$/', $header_value, $match)) {
+                                $this->_data['post'][$match[1]] = $boundary_value;
+                            }
+                        }
+                        break;
+                    case "content-type":
+                        // add file_type
+                        $files[$key]['type'] = \trim($header_value);
+                        break;
+                }
+            }
+        }
+
+        foreach ($files as $file) {
+            $key = $file['key'];
+            unset($file['key']);
+            $this->_data['files'][$key] = $file;
+        }
+    }
+
+    /**
+     * Create session id.
+     *
+     * @return string
+     */
+    protected static function createSessionId()
+    {
+        return \bin2hex(\pack('d', \microtime(true)) . \pack('N', \mt_rand()));
+    }
+
+    /**
+     * Setter.
+     *
+     * @param $name
+     * @param $value
+     * @return void
+     */
+    public function __set($name, $value)
+    {
+        $this->properties[$name] = $value;
+    }
+
+    /**
+     * Getter.
+     *
+     * @param $name
+     * @return mixed|null
+     */
+    public function __get($name)
+    {
+        return isset($this->properties[$name]) ? $this->properties[$name] : null;
+    }
+
+    /**
+     * Isset.
+     *
+     * @param $name
+     * @return bool
+     */
+    public function __isset($name)
+    {
+        return isset($this->properties[$name]);
+    }
+
+    /**
+     * Unset.
+     *
+     * @param $name
+     * @return void
+     */
+    public function __unset($name)
+    {
+        unset($this->properties[$name]);
+    }
+
+    /**
+     * __destruct.
+     *
+     * @return void
+     */
+    public function __destruct()
+    {
+        if (isset($this->_data['files'])) {
+            foreach ($this->_data['files'] as $item) {
+                if (\is_file($item['tmp_name'])) {
+                    \unlink($item['tmp_name']);
+                }
+            }
+        }
+    }
+}

app/gateway/vendor/workerman/workerman/Protocols/Http/Response.php

@@ -0,0 +1,378 @@
+<?php
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author    walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @link      http://www.workerman.net/
+ * @license   http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+namespace Workerman\Protocols\Http;
+
+/**
+ * Class Response
+ * @package Workerman\Protocols\Http
+ */
+class Response
+{
+    /**
+     * Header data.
+     *
+     * @var array
+     */
+    protected $_header = null;
+
+    /**
+     * Http status.
+     *
+     * @var int
+     */
+    protected $_status = null;
+
+    /**
+     * Http reason.
+     *
+     * @var string
+     */
+    protected $_reason = null;
+
+    /**
+     * Http version.
+     *
+     * @var string
+     */
+    protected $_version = '1.1';
+
+    /**
+     * Http body.
+     *
+     * @var string
+     */
+    protected $_body = null;
+
+    /**
+     * Mine type map.
+     * @var array
+     */
+    protected static $_mimeTypeMap = null;
+
+    /**
+     * Phrases.
+     *
+     * @var array
+     */
+    protected static $_phrases = array(
+        100 => 'Continue',
+        101 => 'Switching Protocols',
+        102 => 'Processing',
+        200 => 'OK',
+        201 => 'Created',
+        202 => 'Accepted',
+        203 => 'Non-Authoritative Information',
+        204 => 'No Content',
+        205 => 'Reset Content',
+        206 => 'Partial Content',
+        207 => 'Multi-status',
+        208 => 'Already Reported',
+        300 => 'Multiple Choices',
+        301 => 'Moved Permanently',
+        302 => 'Found',
+        303 => 'See Other',
+        304 => 'Not Modified',
+        305 => 'Use Proxy',
+        306 => 'Switch Proxy',
+        307 => 'Temporary Redirect',
+        400 => 'Bad Request',
+        401 => 'Unauthorized',
+        402 => 'Payment Required',
+        403 => 'Forbidden',
+        404 => 'Not Found',
+        405 => 'Method Not Allowed',
+        406 => 'Not Acceptable',
+        407 => 'Proxy Authentication Required',
+        408 => 'Request Time-out',
+        409 => 'Conflict',
+        410 => 'Gone',
+        411 => 'Length Required',
+        412 => 'Precondition Failed',
+        413 => 'Request Entity Too Large',
+        414 => 'Request-URI Too Large',
+        415 => 'Unsupported Media Type',
+        416 => 'Requested range not satisfiable',
+        417 => 'Expectation Failed',
+        418 => 'I\'m a teapot',
+        422 => 'Unprocessable Entity',
+        423 => 'Locked',
+        424 => 'Failed Dependency',
+        425 => 'Unordered Collection',
+        426 => 'Upgrade Required',
+        428 => 'Precondition Required',
+        429 => 'Too Many Requests',
+        431 => 'Request Header Fields Too Large',
+        451 => 'Unavailable For Legal Reasons',
+        500 => 'Internal Server Error',
+        501 => 'Not Implemented',
+        502 => 'Bad Gateway',
+        503 => 'Service Unavailable',
+        504 => 'Gateway Time-out',
+        505 => 'HTTP Version not supported',
+        506 => 'Variant Also Negotiates',
+        507 => 'Insufficient Storage',
+        508 => 'Loop Detected',
+        511 => 'Network Authentication Required',
+    );
+
+    /**
+     * Init.
+     *
+     * @return void
+     */
+    public static function init() {
+        static::initMimeTypeMap();
+    }
+
+    /**
+     * Response constructor.
+     *
+     * @param int $status
+     * @param array $headers
+     * @param string $body
+     */
+    public function __construct(
+        $status = 200,
+        $headers = array(),
+        $body = ''
+    ) {
+        $this->_status = $status;
+        $this->_header = $headers;
+        $this->_body = $body;
+    }
+
+    /**
+     * Set header.
+     *
+     * @param $name
+     * @param $value
+     * @return $this
+     */
+    public function header($name, $value) {
+        $this->_header[$name] = $value;
+        return $this;
+    }
+
+    /**
+     * Set headers.
+     *
+     * @param $headers
+     * @return $this
+     */
+    public function withHeaders($headers) {
+        $this->_header = \array_merge($this->_header, $headers);
+        return $this;
+    }
+
+    /**
+     * Set status.
+     *
+     * @param $code
+     * @param null $reason_phrase
+     * @return $this
+     */
+    public function withStatus($code, $reason_phrase = null) {
+        $this->_status = $code;
+        $this->_reason = $reason_phrase;
+        return $this;
+    }
+
+    /**
+     * Set protocol version.
+     *
+     * @param $version
+     * @return $this
+     */
+    public function withProtocolVersion($version) {
+        $this->_version = $version;
+        return $this;
+    }
+
+    /**
+     * Set http body.
+     *
+     * @param $body
+     * @return $this
+     */
+    public function withBody($body) {
+        $this->_body = $body;
+        return $this;
+    }
+
+    /**
+     * Send file.
+     *
+     * @param $file
+     * @param int $offset
+     * @param int $length
+     * @return $this
+     */
+    public function withFile($file, $offset = 0, $length = 0) {
+        if (!\is_file($file)) {
+            return $this->withStatus(404)->withBody('<h3>404 Not Found</h3>');
+        }
+        $this->file = array('file' => $file, 'offset' => $offset, 'length' => $length);
+        return $this;
+    }
+
+    /**
+     * Set cookie.
+     *
+     * @param $name
+     * @param string $value
+     * @param int $maxage
+     * @param string $path
+     * @param string $domain
+     * @param bool $secure
+     * @param bool $http_only
+     * @return $this
+     */
+    public function cookie($name, $value = '', $max_age = 0, $path = '', $domain = '', $secure = false, $http_only = false)
+    {
+        $this->_header['Set-Cookie'][] = $name . '=' . \rawurlencode($value)
+            . (empty($domain) ? '' : '; Domain=' . $domain)
+            . (empty($max_age) ? '' : '; Max-Age=' . $max_age)
+            . (empty($path) ? '' : '; Path=' . $path)
+            . (!$secure ? '' : '; Secure')
+            . (!$http_only ? '' : '; HttpOnly');
+        return $this;
+    }
+
+    /**
+     * Create header for file.
+     *
+     * @param $file
+     * @return string
+     */
+    protected function createHeadForFile($file_info)
+    {
+        $file = $file_info['file'];
+        $reason = $this->_reason ? $this->_reason : static::$_phrases[$this->_status];
+        $head = "HTTP/{$this->_version} {$this->_status} $reason\r\n";
+        $headers = $this->_header;
+        if (!isset($headers['Server'])) {
+            $head .= "Server: workerman\r\n";
+        }
+        foreach ($headers as $name => $value) {
+            if (\is_array($value)) {
+                foreach ($value as $item) {
+                    $head .= "$name: $item\r\n";
+                }
+                continue;
+            }
+            $head .= "$name: $value\r\n";
+        }
+
+        if (!isset($headers['Connection'])) {
+            $head .= "Connection: keep-alive\r\n";
+        }
+
+        $file_info = \pathinfo($file);
+        $extension = isset($file_info['extension']) ? $file_info['extension'] : '';
+        $base_name = isset($file_info['basename']) ? $file_info['basename'] : 'unknown';
+        if (!isset($headers['Content-Type'])) {
+            if (isset(self::$_mimeTypeMap[$extension])) {
+                $head .= "Content-Type: " . self::$_mimeTypeMap[$extension] . "\r\n";
+            } else {
+                $head .= "Content-Type: application/octet-stream\r\n";
+            }
+        }
+
+        if (!isset($headers['Content-Disposition']) && !isset(self::$_mimeTypeMap[$extension])) {
+            $head .= "Content-Disposition: attachment; filename=\"$base_name\"\r\n";
+        }
+
+        if (!isset($headers['Last-Modified'])) {
+            if ($mtime = \filemtime($file)) {
+                $head .= 'Last-Modified: '.\date('D, d M Y H:i:s', $mtime) . ' ' . \date_default_timezone_get() ."\r\n";
+            }
+        }
+
+        return "{$head}\r\n";
+    }
+
+    /**
+     * __toString.
+     *
+     * @return string
+     */
+    public function __toString()
+    {
+        if (isset($this->file)) {
+            return $this->createHeadForFile($this->file);
+        }
+
+        $reason = $this->_reason ? $this->_reason : static::$_phrases[$this->_status];
+        $body_len = \strlen($this->_body);
+        if (empty($this->_header)) {
+            return "HTTP/{$this->_version} {$this->_status} $reason\r\nServer: workerman\r\nContent-Type: text/html;charset=utf-8\r\nContent-Length: $body_len\r\nConnection: keep-alive\r\n\r\n{$this->_body}";
+        }
+
+        $head = "HTTP/{$this->_version} {$this->_status} $reason\r\n";
+        $headers = $this->_header;
+        if (!isset($headers['Server'])) {
+            $head .= "Server: workerman\r\n";
+        }
+        foreach ($headers as $name => $value) {
+            if (\is_array($value)) {
+                foreach ($value as $item) {
+                    $head .= "$name: $item\r\n";
+                }
+                continue;
+            }
+            $head .= "$name: $value\r\n";
+        }
+
+        if (!isset($headers['Connection'])) {
+            $head .= "Connection: keep-alive\r\n";
+        }
+
+        if (!isset($headers['Content-Type'])) {
+            $head .= "Content-Type: text/html;charset=utf-8\r\n";
+        } else if ($headers['Content-Type'] === 'text/event-stream') {
+            return $head . $this->_body;
+        }
+
+        if (!isset($headers['Transfer-Encoding'])) {
+            $head .= "Content-Length: $body_len\r\n\r\n";
+        } else {
+            return "$head\r\n".dechex($body_len)."\r\n{$this->_body}\r\n";
+        }
+
+        // The whole http package
+        return $head . $this->_body;
+    }
+
+    /**
+     * Init mime map.
+     *
+     * @return void
+     */
+    public static function initMimeTypeMap()
+    {
+        $mime_file = __DIR__ . '/mime.types';
+        $items = \file($mime_file, \FILE_IGNORE_NEW_LINES | \FILE_SKIP_EMPTY_LINES);
+        foreach ($items as $content) {
+            if (\preg_match("/\s*(\S+)\s+(\S.+)/", $content, $match)) {
+                $mime_type       = $match[1];
+                $extension_var   = $match[2];
+                $extension_array = \explode(' ', \substr($extension_var, 0, -1));
+                foreach ($extension_array as $file_extension) {
+                    static::$_mimeTypeMap[$file_extension] = $mime_type;
+                }
+            }
+        }
+    }
+}
+Response::init();

app/gateway/vendor/workerman/workerman/Protocols/Http/ServerSentEvents.php

@@ -0,0 +1,64 @@
+<?php
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author    walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @link      http://www.workerman.net/
+ * @license   http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+namespace Workerman\Protocols\Http;
+
+/**
+ * Class ServerSentEvents
+ * @package Workerman\Protocols\Http
+ */
+class ServerSentEvents
+{
+    /**
+     * Data.
+     * @var array
+     */
+    protected $_data = null;
+
+    /**
+     * ServerSentEvents constructor.
+     * $data for example ['event'=>'ping', 'data' => 'some thing', 'id' => 1000, 'retry' => 5000]
+     * @param array $data
+     */
+    public function __construct(array $data)
+    {
+        $this->_data = $data;
+    }
+
+    /**
+     * __toString.
+     *
+     * @return string
+     */
+    public function __toString()
+    {
+        $buffer = '';
+        $data = $this->_data;
+        if (isset($data[''])) {
+            $buffer = ": {$data['']}\n";
+        }
+        if (isset($data['event'])) {
+            $buffer .= "event: {$data['event']}\n";
+        }
+        if (isset($data['data'])) {
+            $buffer .= 'data: ' . \str_replace("\n", "\ndata: ", $data['data']) . "\n\n";
+        }
+        if (isset($data['id'])) {
+            $buffer .= "id: {$data['id']}\n";
+        }
+        if (isset($data['retry'])) {
+            $buffer .= "retry: {$data['retry']}\n";
+        }
+        return $buffer;
+    }
+}

app/gateway/vendor/workerman/workerman/Protocols/Http/Session.php

@@ -0,0 +1,359 @@
+<?php
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author    walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @link      http://www.workerman.net/
+ * @license   http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+namespace Workerman\Protocols\Http;
+
+
+/**
+ * Class Session
+ * @package Workerman\Protocols\Http
+ */
+class Session
+{
+    /**
+     * Session andler class which implements SessionHandlerInterface.
+     *
+     * @var string
+     */
+    protected static $_handlerClass = 'Workerman\Protocols\Http\Session\FileSessionHandler';
+
+    /**
+     * Parameters of __constructor for session handler class.
+     *
+     * @var null
+     */
+    protected static $_handlerConfig = null;
+
+    /**
+     * Session.gc_probability
+     *
+     * @var int
+     */
+    protected static $_sessionGcProbability = 1;
+
+    /**
+     * Session.gc_divisor
+     *
+     * @var int
+     */
+    protected static $_sessionGcDivisor = 1000;
+
+    /**
+     * Session.gc_maxlifetime
+     *
+     * @var int
+     */
+    protected static $_sessionGcMaxLifeTime = 1440;
+
+    /**
+     * Session handler instance.
+     *
+     * @var \SessionHandlerInterface
+     */
+    protected static $_handler = null;
+
+    /**
+     * Session data.
+     *
+     * @var array
+     */
+    protected $_data = array();
+
+    /**
+     * Session changed and need to save.
+     *
+     * @var bool
+     */
+    protected $_needSave = false;
+
+    /**
+     * Session id.
+     *
+     * @var null
+     */
+    protected $_sessionId = null;
+
+    /**
+     * Session constructor.
+     *
+     * @param $session_id
+     */
+    public function __construct($session_id)
+    {
+        static::checkSessionId($session_id);
+        if (static::$_handler === null) {
+            static::initHandler();
+        }
+        $this->_sessionId = $session_id;
+        if ($data = static::$_handler->read($session_id)) {
+            $this->_data = \unserialize($data);
+        }
+    }
+
+    /**
+     * Get session id.
+     *
+     * @return string
+     */
+    public function getId()
+    {
+        return $this->_sessionId;
+    }
+
+    /**
+     * Get session.
+     *
+     * @param $name
+     * @param null $default
+     * @return mixed|null
+     */
+    public function get($name, $default = null)
+    {
+        return isset($this->_data[$name]) ? $this->_data[$name] : $default;
+    }
+
+    /**
+     * Store data in the session.
+     *
+     * @param $name
+     * @param $value
+     */
+    public function set($name, $value)
+    {
+        $this->_data[$name] = $value;
+        $this->_needSave = true;
+    }
+
+    /**
+     * Delete an item from the session.
+     *
+     * @param $name
+     */
+    public function delete($name)
+    {
+        unset($this->_data[$name]);
+        $this->_needSave = true;
+    }
+
+    /**
+     * Retrieve and delete an item from the session.
+     *
+     * @param $name
+     * @param null $default
+     * @return mixed|null
+     */
+    public function pull($name, $default = null)
+    {
+        $value = $this->get($name, $default);
+        $this->delete($name);
+        return $value;
+    }
+
+    /**
+     * Store data in the session.
+     *
+     * @param $key
+     * @param null $value
+     */
+    public function put($key, $value = null)
+    {
+        if (!\is_array($key)) {
+            $this->set($key, $value);
+            return;
+        }
+
+        foreach ($key as $k => $v) {
+            $this->_data[$k] = $v;
+        }
+        $this->_needSave = true;
+    }
+
+    /**
+     * Remove a piece of data from the session.
+     *
+     * @param $name
+     */
+    public function forget($name)
+    {
+        if (\is_scalar($name)) {
+            $this->delete($name);
+            return;
+        }
+        if (\is_array($name)) {
+            foreach ($name as $key) {
+                unset($this->_data[$key]);
+            }
+        }
+        $this->_needSave = true;
+    }
+
+    /**
+     * Retrieve all the data in the session.
+     *
+     * @return array
+     */
+    public function all()
+    {
+        return $this->_data;
+    }
+
+    /**
+     * Remove all data from the session.
+     *
+     * @return void
+     */
+    public function flush()
+    {
+        $this->_needSave = true;
+        $this->_data = array();
+    }
+
+    /**
+     * Determining If An Item Exists In The Session.
+     *
+     * @param $name
+     * @return bool
+     */
+    public function has($name)
+    {
+        return isset($this->_data[$name]);
+    }
+
+    /**
+     * To determine if an item is present in the session, even if its value is null.
+     *
+     * @param $name
+     * @return bool
+     */
+    public function exists($name)
+    {
+        return \array_key_exists($name, $this->_data);
+    }
+
+    /**
+     * Save session to store.
+     *
+     * @return void
+     */
+    public function save()
+    {
+        if ($this->_needSave) {
+            if (empty($this->_data)) {
+                static::$_handler->destroy($this->_sessionId);
+            } else {
+                static::$_handler->write($this->_sessionId, \serialize($this->_data));
+            }
+        }
+        $this->_needSave = false;
+    }
+
+    /**
+     * Init.
+     *
+     * @return void
+     */
+    public static function init()
+    {
+        if ($gc_probability = \ini_get('session.gc_probability')) {
+            self::$_sessionGcProbability = (int)$gc_probability;
+        }
+
+        if ($gc_divisor = \ini_get('session.gc_divisor')) {
+            self::$_sessionGcDivisor = (int)$gc_divisor;
+        }
+
+        if ($gc_max_life_time = \ini_get('session.gc_maxlifetime')) {
+            self::$_sessionGcMaxLifeTime = (int)$gc_max_life_time;
+        }
+    }
+
+    /**
+     * Set session handler class.
+     *
+     * @param null $class_name
+     * @param null $config
+     * @return string
+     */
+    public static function handlerClass($class_name = null, $config = null)
+    {
+        if ($class_name) {
+            static::$_handlerClass = $class_name;
+        }
+        if ($config) {
+            static::$_handlerConfig = $config;
+        }
+        return static::$_handlerClass;
+    }
+
+    /**
+     * Init handler.
+     *
+     * @return void
+     */
+    protected static function initHandler()
+    {
+        if (static::$_handlerConfig === null) {
+            static::$_handler = new static::$_handlerClass();
+        } else {
+            static::$_handler = new static::$_handlerClass(static::$_handlerConfig);
+        }
+    }
+
+    /**
+     * Try GC sessions.
+     *
+     * @return void
+     */
+    public function tryGcSessions()
+    {
+        if (\rand(1, static::$_sessionGcDivisor) > static::$_sessionGcProbability) {
+            return;
+        }
+        static::$_handler->gc(static::$_sessionGcMaxLifeTime);
+    }
+
+    /**
+     * __destruct.
+     *
+     * @return void
+     */
+    public function __destruct()
+    {
+        $this->save();
+        $this->tryGcSessions();
+    }
+
+    /**
+     * Check session id.
+     *
+     * @param $session_id
+     */
+    protected static function checkSessionId($session_id)
+    {
+        if (!\preg_match('/^[a-zA-Z0-9]+$/', $session_id)) {
+            throw new SessionException("session_id $session_id is invalid");
+        }
+    }
+}
+
+/**
+ * Class SessionException
+ * @package Workerman\Protocols\Http
+ */
+class SessionException extends \RuntimeException
+{
+
+}
+
+// Init session.
+Session::init();

app/gateway/vendor/workerman/workerman/Protocols/Http/Session/FileSessionHandler.php

@@ -0,0 +1,153 @@
+<?php
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author    walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @link      http://www.workerman.net/
+ * @license   http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+namespace Workerman\Protocols\Http\Session;
+
+/**
+ * Class FileSessionHandler
+ * @package Workerman\Protocols\Http\Session
+ */
+class FileSessionHandler implements \SessionHandlerInterface
+{
+    /**
+     * Session save path.
+     *
+     * @var string
+     */
+    protected static $_sessionSavePath = null;
+
+    /**
+     * Session file prefix.
+     *
+     * @var string
+     */
+    protected static $_sessionFilePrefix = 'session_';
+
+    /**
+     * Init.
+     */
+    public static function init() {
+        $save_path = @\session_save_path();
+        if (!$save_path || \strpos($save_path, 'tcp://') === 0) {
+            $save_path = \sys_get_temp_dir();
+        }
+        static::sessionSavePath($save_path);
+    }
+
+    /**
+     * FileSessionHandler constructor.
+     * @param array $config
+     */
+    public function __construct($config = array()) {
+        if (isset($config['save_path'])) {
+            static::sessionSavePath($config['save_path']);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function open($save_path, $name)
+    {
+        return true;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function read($session_id)
+    {
+        $session_file = static::sessionFile($session_id);
+        \clearstatcache();
+        if (\is_file($session_file)) {
+            $data = \file_get_contents($session_file);
+            return $data ? $data : '';
+        }
+        return '';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function write($session_id, $session_data)
+    {
+        $temp_file = static::$_sessionSavePath.uniqid(mt_rand(), true);
+        if (!\file_put_contents($temp_file, $session_data)) {
+            return false;
+        }
+        return \rename($temp_file, static::sessionFile($session_id));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function close()
+    {
+        return true;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function destroy($session_id)
+    {
+        $session_file = static::sessionFile($session_id);
+        if (\is_file($session_file)) {
+            \unlink($session_file);
+        }
+        return true;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function gc($maxlifetime) {
+        $time_now = \time();
+        foreach (\glob(static::$_sessionSavePath . static::$_sessionFilePrefix . '*') as $file) {
+            if(\is_file($file) && $time_now - \filemtime($file) > $maxlifetime) {
+                \unlink($file);
+            }
+        }
+    }
+
+    /**
+     * Get session file path.
+     *
+     * @param $session_id
+     * @return string
+     */
+    protected static function sessionFile($session_id) {
+        return static::$_sessionSavePath.static::$_sessionFilePrefix.$session_id;
+    }
+
+    /**
+     * Get or set session file path.
+     *
+     * @param $path
+     * @return string
+     */
+    public static function sessionSavePath($path) {
+        if ($path) {
+            if ($path[\strlen($path)-1] !== DIRECTORY_SEPARATOR) {
+                $path .= DIRECTORY_SEPARATOR;
+            }
+            static::$_sessionSavePath = $path;
+            if (!\is_dir($path)) {
+                \mkdir($path, 0777, true);
+            }
+        }
+        return $path;
+    }
+}
+
+FileSessionHandler::init();

app/gateway/vendor/workerman/workerman/Protocols/Http/Session/RedisSessionHandler.php

@@ -0,0 +1,119 @@
+<?php
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author    walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @link      http://www.workerman.net/
+ * @license   http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+namespace Workerman\Protocols\Http\Session;
+
+/**
+ * Class RedisSessionHandler
+ * @package Workerman\Protocols\Http\Session
+ */
+class RedisSessionHandler extends \SessionHandler
+{
+
+    /**
+     * @var \Redis
+     */
+    protected $_redis;
+
+    /**
+     * @var int
+     */
+    protected $_maxLifeTime;
+
+    /**
+     * RedisSessionHandler constructor.
+     * @param $config = [
+     *  'host'     => '127.0.0.1',
+     *  'port'     => 6379,
+     *  'timeout'  => 2,
+     *  'auth'     => '******',
+     *  'database' => 2,
+     *  'prefix'   => 'redis_session_',
+     * ]
+     */
+    public function __construct($config)
+    {
+        if (false === extension_loaded('redis')) {
+            throw new \RuntimeException('Please install redis extension.');
+        }
+        $this->_maxLifeTime = (int)ini_get('session.gc_maxlifetime');
+
+        if (!isset($config['timeout'])) {
+            $config['timeout'] = 2;
+        }
+
+        $this->_redis = new \Redis();
+        if (false === $this->_redis->connect($config['host'], $config['port'], $config['timeout'])) {
+            throw new \RuntimeException("Redis connect {$config['host']}:{$config['port']} fail.");
+        }
+        if (!empty($config['auth'])) {
+            $this->_redis->auth($config['auth']);
+        }
+        if (!empty($config['database'])) {
+            $this->_redis->select($config['database']);
+        }
+        if (empty($config['prefix'])) {
+            $config['prefix'] = 'redis_session_';
+        }
+        $this->_redis->setOption(\Redis::OPT_PREFIX, $config['prefix']);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function open($save_path, $name)
+    {
+        return true;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function read($session_id)
+    {
+        return $this->_redis->get($session_id);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function write($session_id, $session_data)
+    {
+        return true === $this->_redis->setex($session_id, $this->_maxLifeTime, $session_data);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function destroy($session_id)
+    {
+        $this->_redis->del($session_id);
+        return true;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function close()
+    {
+        return true;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function gc($maxlifetime)
+    {
+        return true;
+    }
+}

app/gateway/vendor/workerman/workerman/Protocols/Http/mime.types

@@ -0,0 +1,90 @@
+
+types {
+    text/html                             html htm shtml;
+    text/css                              css;
+    text/xml                              xml;
+    image/gif                             gif;
+    image/jpeg                            jpeg jpg;
+    application/javascript                js;
+    application/atom+xml                  atom;
+    application/rss+xml                   rss;
+
+    text/mathml                           mml;
+    text/plain                            txt;
+    text/vnd.sun.j2me.app-descriptor      jad;
+    text/vnd.wap.wml                      wml;
+    text/x-component                      htc;
+
+    image/png                             png;
+    image/tiff                            tif tiff;
+    image/vnd.wap.wbmp                    wbmp;
+    image/x-icon                          ico;
+    image/x-jng                           jng;
+    image/x-ms-bmp                        bmp;
+    image/svg+xml                         svg svgz;
+    image/webp                            webp;
+
+    application/font-woff                 woff;
+    application/java-archive              jar war ear;
+    application/json                      json;
+    application/mac-binhex40              hqx;
+    application/msword                    doc;
+    application/pdf                       pdf;
+    application/postscript                ps eps ai;
+    application/rtf                       rtf;
+    application/vnd.apple.mpegurl         m3u8;
+    application/vnd.ms-excel              xls;
+    application/vnd.ms-fontobject         eot;
+    application/vnd.ms-powerpoint         ppt;
+    application/vnd.wap.wmlc              wmlc;
+    application/vnd.google-earth.kml+xml  kml;
+    application/vnd.google-earth.kmz      kmz;
+    application/x-7z-compressed           7z;
+    application/x-cocoa                   cco;
+    application/x-java-archive-diff       jardiff;
+    application/x-java-jnlp-file          jnlp;
+    application/x-makeself                run;
+    application/x-perl                    pl pm;
+    application/x-pilot                   prc pdb;
+    application/x-rar-compressed          rar;
+    application/x-redhat-package-manager  rpm;
+    application/x-sea                     sea;
+    application/x-shockwave-flash         swf;
+    application/x-stuffit                 sit;
+    application/x-tcl                     tcl tk;
+    application/x-x509-ca-cert            der pem crt;
+    application/x-xpinstall               xpi;
+    application/xhtml+xml                 xhtml;
+    application/xspf+xml                  xspf;
+    application/zip                       zip;
+
+    application/octet-stream              bin exe dll;
+    application/octet-stream              deb;
+    application/octet-stream              dmg;
+    application/octet-stream              iso img;
+    application/octet-stream              msi msp msm;
+
+    application/vnd.openxmlformats-officedocument.wordprocessingml.document    docx;
+    application/vnd.openxmlformats-officedocument.spreadsheetml.sheet          xlsx;
+    application/vnd.openxmlformats-officedocument.presentationml.presentation  pptx;
+
+    audio/midi                            mid midi kar;
+    audio/mpeg                            mp3;
+    audio/ogg                             ogg;
+    audio/x-m4a                           m4a;
+    audio/x-realaudio                     ra;
+
+    video/3gpp                            3gpp 3gp;
+    video/mp2t                            ts;
+    video/mp4                             mp4;
+    video/mpeg                            mpeg mpg;
+    video/quicktime                       mov;
+    video/webm                            webm;
+    video/x-flv                           flv;
+    video/x-m4v                           m4v;
+    video/x-mng                           mng;
+    video/x-ms-asf                        asx asf;
+    video/x-ms-wmv                        wmv;
+    video/x-msvideo                       avi;
+    font/ttf                              ttf;
+}

app/gateway/vendor/workerman/workerman/Protocols/ProtocolInterface.php

@@ -0,0 +1,52 @@
+<?php
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author    walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @link      http://www.workerman.net/
+ * @license   http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+namespace Workerman\Protocols;
+
+use Workerman\Connection\ConnectionInterface;
+
+/**
+ * Protocol interface
+ */
+interface ProtocolInterface
+{
+    /**
+     * Check the integrity of the package.
+     * Please return the length of package.
+     * If length is unknow please return 0 that mean wating more data.
+     * If the package has something wrong please return false the connection will be closed.
+     *
+     * @param string              $recv_buffer
+     * @param ConnectionInterface $connection
+     * @return int|false
+     */
+    public static function input($recv_buffer, ConnectionInterface $connection);
+
+    /**
+     * Decode package and emit onMessage($message) callback, $message is the result that decode returned.
+     *
+     * @param string              $recv_buffer
+     * @param ConnectionInterface $connection
+     * @return mixed
+     */
+    public static function decode($recv_buffer, ConnectionInterface $connection);
+
+    /**
+     * Encode package brefore sending to client.
+     * 
+     * @param mixed               $data
+     * @param ConnectionInterface $connection
+     * @return string
+     */
+    public static function encode($data, ConnectionInterface $connection);
+}

app/gateway/vendor/workerman/workerman/Protocols/Text.php

@@ -0,0 +1,70 @@
+<?php
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author    walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @link      http://www.workerman.net/
+ * @license   http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+namespace Workerman\Protocols;
+
+use Workerman\Connection\ConnectionInterface;
+
+/**
+ * Text Protocol.
+ */
+class Text
+{
+    /**
+     * Check the integrity of the package.
+     *
+     * @param string        $buffer
+     * @param ConnectionInterface $connection
+     * @return int
+     */
+    public static function input($buffer, ConnectionInterface $connection)
+    {
+        // Judge whether the package length exceeds the limit.
+        if (isset($connection->maxPackageSize) && \strlen($buffer) >= $connection->maxPackageSize) {
+            $connection->close();
+            return 0;
+        }
+        //  Find the position of  "\n".
+        $pos = \strpos($buffer, "\n");
+        // No "\n", packet length is unknown, continue to wait for the data so return 0.
+        if ($pos === false) {
+            return 0;
+        }
+        // Return the current package length.
+        return $pos + 1;
+    }
+
+    /**
+     * Encode.
+     *
+     * @param string $buffer
+     * @return string
+     */
+    public static function encode($buffer)
+    {
+        // Add "\n"
+        return $buffer . "\n";
+    }
+
+    /**
+     * Decode.
+     *
+     * @param string $buffer
+     * @return string
+     */
+    public static function decode($buffer)
+    {
+        // Remove "\n"
+        return \rtrim($buffer, "\r\n");
+    }
+}

app/gateway/vendor/workerman/workerman/Protocols/Websocket.php

@@ -0,0 +1,503 @@
+<?php
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author    walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @link      http://www.workerman.net/
+ * @license   http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+namespace Workerman\Protocols;
+
+use Workerman\Connection\ConnectionInterface;
+use Workerman\Connection\TcpConnection;
+use Workerman\Worker;
+
+/**
+ * WebSocket protocol.
+ */
+class Websocket implements \Workerman\Protocols\ProtocolInterface
+{
+    /**
+     * Websocket blob type.
+     *
+     * @var string
+     */
+    const BINARY_TYPE_BLOB = "\x81";
+
+    /**
+     * Websocket arraybuffer type.
+     *
+     * @var string
+     */
+    const BINARY_TYPE_ARRAYBUFFER = "\x82";
+
+    /**
+     * Check the integrity of the package.
+     *
+     * @param string              $buffer
+     * @param ConnectionInterface $connection
+     * @return int
+     */
+    public static function input($buffer, ConnectionInterface $connection)
+    {
+        // Receive length.
+        $recv_len = \strlen($buffer);
+        // We need more data.
+        if ($recv_len < 6) {
+            return 0;
+        }
+
+        // Has not yet completed the handshake.
+        if (empty($connection->websocketHandshake)) {
+            return static::dealHandshake($buffer, $connection);
+        }
+
+        // Buffer websocket frame data.
+        if ($connection->websocketCurrentFrameLength) {
+            // We need more frame data.
+            if ($connection->websocketCurrentFrameLength > $recv_len) {
+                // Return 0, because it is not clear the full packet length, waiting for the frame of fin=1.
+                return 0;
+            }
+        } else {
+            $firstbyte    = \ord($buffer[0]);
+            $secondbyte   = \ord($buffer[1]);
+            $data_len     = $secondbyte & 127;
+            $is_fin_frame = $firstbyte >> 7;
+            $masked       = $secondbyte >> 7;
+
+            if (!$masked) {
+                Worker::safeEcho("frame not masked so close the connection\n");
+                $connection->close();
+                return 0;
+            }
+
+            $opcode       = $firstbyte & 0xf;
+            switch ($opcode) {
+                case 0x0:
+                    break;
+                // Blob type.
+                case 0x1:
+                    break;
+                // Arraybuffer type.
+                case 0x2:
+                    break;
+                // Close package.
+                case 0x8:
+                    // Try to emit onWebSocketClose callback.
+                    if (isset($connection->onWebSocketClose) || isset($connection->worker->onWebSocketClose)) {
+                        try {
+                            \call_user_func(isset($connection->onWebSocketClose)?$connection->onWebSocketClose:$connection->worker->onWebSocketClose, $connection);
+                        } catch (\Exception $e) {
+                            Worker::log($e);
+                            exit(250);
+                        } catch (\Error $e) {
+                            Worker::log($e);
+                            exit(250);
+                        }
+                    } // Close connection.
+                    else {
+                        $connection->close("\x88\x02\x03\xe8", true);
+                    }
+                    return 0;
+                // Ping package.
+                case 0x9:
+                    break;
+                // Pong package.
+                case 0xa:
+                    break;
+                // Wrong opcode. 
+                default :
+                    Worker::safeEcho("error opcode $opcode and close websocket connection. Buffer:" . bin2hex($buffer) . "\n");
+                    $connection->close();
+                    return 0;
+            }
+
+            // Calculate packet length.
+            $head_len = 6;
+            if ($data_len === 126) {
+                $head_len = 8;
+                if ($head_len > $recv_len) {
+                    return 0;
+                }
+                $pack     = \unpack('nn/ntotal_len', $buffer);
+                $data_len = $pack['total_len'];
+            } else {
+                if ($data_len === 127) {
+                    $head_len = 14;
+                    if ($head_len > $recv_len) {
+                        return 0;
+                    }
+                    $arr      = \unpack('n/N2c', $buffer);
+                    $data_len = $arr['c1']*4294967296 + $arr['c2'];
+                }
+            }
+            $current_frame_length = $head_len + $data_len;
+
+            $total_package_size = \strlen($connection->websocketDataBuffer) + $current_frame_length;
+            if ($total_package_size > $connection->maxPackageSize) {
+                Worker::safeEcho("error package. package_length=$total_package_size\n");
+                $connection->close();
+                return 0;
+            }
+
+            if ($is_fin_frame) {
+                if ($opcode === 0x9) {
+                    if ($recv_len >= $current_frame_length) {
+                        $ping_data = static::decode(\substr($buffer, 0, $current_frame_length), $connection);
+                        $connection->consumeRecvBuffer($current_frame_length);
+                        $tmp_connection_type = isset($connection->websocketType) ? $connection->websocketType : static::BINARY_TYPE_BLOB;
+                        $connection->websocketType = "\x8a";
+                        if (isset($connection->onWebSocketPing) || isset($connection->worker->onWebSocketPing)) {
+                            try {
+                                \call_user_func(isset($connection->onWebSocketPing)?$connection->onWebSocketPing:$connection->worker->onWebSocketPing, $connection, $ping_data);
+                            } catch (\Exception $e) {
+                                Worker::log($e);
+                                exit(250);
+                            } catch (\Error $e) {
+                                Worker::log($e);
+                                exit(250);
+                            }
+                        } else {
+                            $connection->send($ping_data);
+                        }
+                        $connection->websocketType = $tmp_connection_type;
+                        if ($recv_len > $current_frame_length) {
+                            return static::input(\substr($buffer, $current_frame_length), $connection);
+                        }
+                    }
+                    return 0;
+                } else if ($opcode === 0xa) {
+                    if ($recv_len >= $current_frame_length) {
+                        $pong_data = static::decode(\substr($buffer, 0, $current_frame_length), $connection);
+                        $connection->consumeRecvBuffer($current_frame_length);
+                        $tmp_connection_type = isset($connection->websocketType) ? $connection->websocketType : static::BINARY_TYPE_BLOB;
+                        $connection->websocketType = "\x8a";
+                        // Try to emit onWebSocketPong callback.
+                        if (isset($connection->onWebSocketPong) || isset($connection->worker->onWebSocketPong)) {
+                            try {
+                                \call_user_func(isset($connection->onWebSocketPong)?$connection->onWebSocketPong:$connection->worker->onWebSocketPong, $connection, $pong_data);
+                            } catch (\Exception $e) {
+                                Worker::log($e);
+                                exit(250);
+                            } catch (\Error $e) {
+                                Worker::log($e);
+                                exit(250);
+                            }
+                        }
+                        $connection->websocketType = $tmp_connection_type;
+                        if ($recv_len > $current_frame_length) {
+                            return static::input(\substr($buffer, $current_frame_length), $connection);
+                        }
+                    }
+                    return 0;
+                }
+                return $current_frame_length;
+            } else {
+                $connection->websocketCurrentFrameLength = $current_frame_length;
+            }
+        }
+
+        // Received just a frame length data.
+        if ($connection->websocketCurrentFrameLength === $recv_len) {
+            static::decode($buffer, $connection);
+            $connection->consumeRecvBuffer($connection->websocketCurrentFrameLength);
+            $connection->websocketCurrentFrameLength = 0;
+            return 0;
+        } // The length of the received data is greater than the length of a frame.
+        elseif ($connection->websocketCurrentFrameLength < $recv_len) {
+            static::decode(\substr($buffer, 0, $connection->websocketCurrentFrameLength), $connection);
+            $connection->consumeRecvBuffer($connection->websocketCurrentFrameLength);
+            $current_frame_length                    = $connection->websocketCurrentFrameLength;
+            $connection->websocketCurrentFrameLength = 0;
+            // Continue to read next frame.
+            return static::input(\substr($buffer, $current_frame_length), $connection);
+        } // The length of the received data is less than the length of a frame.
+        else {
+            return 0;
+        }
+    }
+
+    /**
+     * Websocket encode.
+     *
+     * @param string              $buffer
+     * @param ConnectionInterface $connection
+     * @return string
+     */
+    public static function encode($buffer, ConnectionInterface $connection)
+    {
+        if (!is_scalar($buffer)) {
+            throw new \Exception("You can't send(" . \gettype($buffer) . ") to client, you need to convert it to a string. ");
+        }
+        $len = \strlen($buffer);
+        if (empty($connection->websocketType)) {
+            $connection->websocketType = static::BINARY_TYPE_BLOB;
+        }
+
+        $first_byte = $connection->websocketType;
+
+        if ($len <= 125) {
+            $encode_buffer = $first_byte . \chr($len) . $buffer;
+        } else {
+            if ($len <= 65535) {
+                $encode_buffer = $first_byte . \chr(126) . \pack("n", $len) . $buffer;
+            } else {
+                $encode_buffer = $first_byte . \chr(127) . \pack("xxxxN", $len) . $buffer;
+            }
+        }
+
+        // Handshake not completed so temporary buffer websocket data waiting for send.
+        if (empty($connection->websocketHandshake)) {
+            if (empty($connection->tmpWebsocketData)) {
+                $connection->tmpWebsocketData = '';
+            }
+            // If buffer has already full then discard the current package.
+            if (\strlen($connection->tmpWebsocketData) > $connection->maxSendBufferSize) {
+                if ($connection->onError) {
+                    try {
+                        \call_user_func($connection->onError, $connection, \WORKERMAN_SEND_FAIL, 'send buffer full and drop package');
+                    } catch (\Exception $e) {
+                        Worker::log($e);
+                        exit(250);
+                    } catch (\Error $e) {
+                        Worker::log($e);
+                        exit(250);
+                    }
+                }
+                return '';
+            }
+            $connection->tmpWebsocketData .= $encode_buffer;
+            // Check buffer is full.
+            if ($connection->maxSendBufferSize <= \strlen($connection->tmpWebsocketData)) {
+                if ($connection->onBufferFull) {
+                    try {
+                        \call_user_func($connection->onBufferFull, $connection);
+                    } catch (\Exception $e) {
+                        Worker::log($e);
+                        exit(250);
+                    } catch (\Error $e) {
+                        Worker::log($e);
+                        exit(250);
+                    }
+                }
+            }
+
+            // Return empty string.
+            return '';
+        }
+
+        return $encode_buffer;
+    }
+
+    /**
+     * Websocket decode.
+     *
+     * @param string              $buffer
+     * @param ConnectionInterface $connection
+     * @return string
+     */
+    public static function decode($buffer, ConnectionInterface $connection)
+    {
+        $len = \ord($buffer[1]) & 127;
+        if ($len === 126) {
+            $masks = \substr($buffer, 4, 4);
+            $data  = \substr($buffer, 8);
+        } else {
+            if ($len === 127) {
+                $masks = \substr($buffer, 10, 4);
+                $data  = \substr($buffer, 14);
+            } else {
+                $masks = \substr($buffer, 2, 4);
+                $data  = \substr($buffer, 6);
+            }
+        }
+        $dataLength = \strlen($data);
+        $masks = \str_repeat($masks, \floor($dataLength / 4)) . \substr($masks, 0, $dataLength % 4);
+        $decoded = $data ^ $masks;
+        if ($connection->websocketCurrentFrameLength) {
+            $connection->websocketDataBuffer .= $decoded;
+            return $connection->websocketDataBuffer;
+        } else {
+            if ($connection->websocketDataBuffer !== '') {
+                $decoded                         = $connection->websocketDataBuffer . $decoded;
+                $connection->websocketDataBuffer = '';
+            }
+            return $decoded;
+        }
+    }
+
+    /**
+     * Websocket handshake.
+     *
+     * @param string                              $buffer
+     * @param TcpConnection $connection
+     * @return int
+     */
+    public static function dealHandshake($buffer, TcpConnection $connection)
+    {
+        // HTTP protocol.
+        if (0 === \strpos($buffer, 'GET')) {
+            // Find \r\n\r\n.
+            $heder_end_pos = \strpos($buffer, "\r\n\r\n");
+            if (!$heder_end_pos) {
+                return 0;
+            }
+            $header_length = $heder_end_pos + 4;
+
+            // Get Sec-WebSocket-Key.
+            $Sec_WebSocket_Key = '';
+            if (\preg_match("/Sec-WebSocket-Key: *(.*?)\r\n/i", $buffer, $match)) {
+                $Sec_WebSocket_Key = $match[1];
+            } else {
+                $connection->send("HTTP/1.1 200 Websocket\r\nServer: workerman/".Worker::VERSION."\r\n\r\n<div style=\"text-align:center\"><h1>Websocket</h1><hr>powered by <a href=\"https://www.workerman.net\">workerman ".Worker::VERSION."</a></div>",
+                    true);
+                $connection->close();
+                return 0;
+            }
+            // Calculation websocket key.
+            $new_key = \base64_encode(\sha1($Sec_WebSocket_Key . "258EAFA5-E914-47DA-95CA-C5AB0DC85B11", true));
+            // Handshake response data.
+            $handshake_message = "HTTP/1.1 101 Switching Protocols\r\n"
+                                ."Upgrade: websocket\r\n"
+                                ."Sec-WebSocket-Version: 13\r\n"
+                                ."Connection: Upgrade\r\n"
+                                ."Sec-WebSocket-Accept: " . $new_key . "\r\n";
+
+            // Websocket data buffer.
+            $connection->websocketDataBuffer = '';
+            // Current websocket frame length.
+            $connection->websocketCurrentFrameLength = 0;
+            // Current websocket frame data.
+            $connection->websocketCurrentFrameBuffer = '';
+            // Consume handshake data.
+            $connection->consumeRecvBuffer($header_length);
+
+            // blob or arraybuffer
+            if (empty($connection->websocketType)) {
+                $connection->websocketType = static::BINARY_TYPE_BLOB;
+            }
+
+            $has_server_header = false;
+
+            // Try to emit onWebSocketConnect callback.
+            if (isset($connection->onWebSocketConnect) || isset($connection->worker->onWebSocketConnect)) {
+                static::parseHttpHeader($buffer);
+                try {
+                    \call_user_func(isset($connection->onWebSocketConnect)?$connection->onWebSocketConnect:$connection->worker->onWebSocketConnect, $connection, $buffer);
+                } catch (\Exception $e) {
+                    Worker::log($e);
+                    exit(250);
+                } catch (\Error $e) {
+                    Worker::log($e);
+                    exit(250);
+                }
+                if (!empty($_SESSION) && \class_exists('\GatewayWorker\Lib\Context')) {
+                    $connection->session = \GatewayWorker\Lib\Context::sessionEncode($_SESSION);
+                }
+                $_GET = $_SERVER = $_SESSION = $_COOKIE = array();
+
+                if (isset($connection->headers)) {
+                    if (\is_array($connection->headers))  {
+                        foreach ($connection->headers as $header) {
+                            if (\strpos($header, 'Server:') === 0) {
+                                $has_server_header = true;
+                            }
+                            $handshake_message .= "$header\r\n";
+                        }
+                    } else {
+                        $handshake_message .= "$connection->headers\r\n";
+                    }
+                }
+            }
+            if (!$has_server_header) {
+                $handshake_message .= "Server: workerman/".Worker::VERSION."\r\n";
+            }
+            $handshake_message .= "\r\n";
+            // Send handshake response.
+            $connection->send($handshake_message, true);
+            // Mark handshake complete..
+            $connection->websocketHandshake = true;
+            // There are data waiting to be sent.
+            if (!empty($connection->tmpWebsocketData)) {
+                $connection->send($connection->tmpWebsocketData, true);
+                $connection->tmpWebsocketData = '';
+            }
+            if (\strlen($buffer) > $header_length) {
+                return static::input(\substr($buffer, $header_length), $connection);
+            }
+            return 0;
+        } // Is flash policy-file-request.
+        elseif (0 === \strpos($buffer, '<polic')) {
+            $policy_xml = '<?xml version="1.0"?><cross-domain-policy><site-control permitted-cross-domain-policies="all"/><allow-access-from domain="*" to-ports="*"/></cross-domain-policy>' . "\0";
+            $connection->send($policy_xml, true);
+            $connection->consumeRecvBuffer(\strlen($buffer));
+            return 0;
+        }
+        // Bad websocket handshake request.
+        $connection->send("HTTP/1.1 200 Websocket\r\nServer: workerman/".Worker::VERSION."\r\n\r\n<div style=\"text-align:center\"><h1>Websocket</h1><hr>powered by <a href=\"https://www.workerman.net\">workerman ".Worker::VERSION."</a></div>",
+            true);
+        $connection->close();
+        return 0;
+    }
+
+    /**
+     * Parse http header.
+     *
+     * @param string $buffer
+     * @return void
+     */
+    protected static function parseHttpHeader($buffer)
+    {
+        // Parse headers.
+        list($http_header, ) = \explode("\r\n\r\n", $buffer, 2);
+        $header_data = \explode("\r\n", $http_header);
+
+        if ($_SERVER) {
+            $_SERVER = array();
+        }
+
+        list($_SERVER['REQUEST_METHOD'], $_SERVER['REQUEST_URI'], $_SERVER['SERVER_PROTOCOL']) = \explode(' ',
+            $header_data[0]);
+
+        unset($header_data[0]);
+        foreach ($header_data as $content) {
+            // \r\n\r\n
+            if (empty($content)) {
+                continue;
+            }
+            list($key, $value)       = \explode(':', $content, 2);
+            $key                     = \str_replace('-', '_', \strtoupper($key));
+            $value                   = \trim($value);
+            $_SERVER['HTTP_' . $key] = $value;
+            switch ($key) {
+                // HTTP_HOST
+                case 'HOST':
+                    $tmp                    = \explode(':', $value);
+                    $_SERVER['SERVER_NAME'] = $tmp[0];
+                    if (isset($tmp[1])) {
+                        $_SERVER['SERVER_PORT'] = $tmp[1];
+                    }
+                    break;
+                // cookie
+                case 'COOKIE':
+                    \parse_str(\str_replace('; ', '&', $_SERVER['HTTP_COOKIE']), $_COOKIE);
+                    break;
+            }
+        }
+
+        // QUERY_STRING
+        $_SERVER['QUERY_STRING'] = \parse_url($_SERVER['REQUEST_URI'], \PHP_URL_QUERY);
+        if ($_SERVER['QUERY_STRING']) {
+            // $GET
+            \parse_str($_SERVER['QUERY_STRING'], $_GET);
+        } else {
+            $_SERVER['QUERY_STRING'] = '';
+        }
+    }
+}

app/gateway/vendor/workerman/workerman/Protocols/Ws.php

@@ -0,0 +1,472 @@
+<?php
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author    walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @link      http://www.workerman.net/
+ * @license   http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+namespace Workerman\Protocols;
+
+use Workerman\Worker;
+use Workerman\Lib\Timer;
+use Workerman\Connection\TcpConnection;
+use Workerman\Connection\ConnectionInterface;
+
+/**
+ * Websocket protocol for client.
+ */
+class Ws
+{
+    /**
+     * Websocket blob type.
+     *
+     * @var string
+     */
+    const BINARY_TYPE_BLOB = "\x81";
+
+    /**
+     * Websocket arraybuffer type.
+     *
+     * @var string
+     */
+    const BINARY_TYPE_ARRAYBUFFER = "\x82";
+
+    /**
+     * Check the integrity of the package.
+     *
+     * @param string              $buffer
+     * @param ConnectionInterface $connection
+     * @return int
+     */
+    public static function input($buffer, ConnectionInterface $connection)
+    {
+        if (empty($connection->handshakeStep)) {
+            Worker::safeEcho("recv data before handshake. Buffer:" . \bin2hex($buffer) . "\n");
+            return false;
+        }
+        // Recv handshake response
+        if ($connection->handshakeStep === 1) {
+            return self::dealHandshake($buffer, $connection);
+        }
+        $recv_len = \strlen($buffer);
+        if ($recv_len < 2) {
+            return 0;
+        }
+        // Buffer websocket frame data.
+        if ($connection->websocketCurrentFrameLength) {
+            // We need more frame data.
+            if ($connection->websocketCurrentFrameLength > $recv_len) {
+                // Return 0, because it is not clear the full packet length, waiting for the frame of fin=1.
+                return 0;
+            }
+        } else {
+
+            $firstbyte    = \ord($buffer[0]);
+            $secondbyte   = \ord($buffer[1]);
+            $data_len     = $secondbyte & 127;
+            $is_fin_frame = $firstbyte >> 7;
+            $masked       = $secondbyte >> 7;
+
+            if ($masked) {
+                Worker::safeEcho("frame masked so close the connection\n");
+                $connection->close();
+                return 0;
+            }
+
+            $opcode       = $firstbyte & 0xf;
+
+            switch ($opcode) {
+                case 0x0:
+                    break;
+                // Blob type.
+                case 0x1:
+                    break;
+                // Arraybuffer type.
+                case 0x2:
+                    break;
+                // Close package.
+                case 0x8:
+                    // Try to emit onWebSocketClose callback.
+                    if (isset($connection->onWebSocketClose)) {
+                        try {
+                            \call_user_func($connection->onWebSocketClose, $connection);
+                        } catch (\Exception $e) {
+                            Worker::log($e);
+                            exit(250);
+                        } catch (\Error $e) {
+                            Worker::log($e);
+                            exit(250);
+                        }
+                    } // Close connection.
+                    else {
+                        $connection->close();
+                    }
+                    return 0;
+                // Ping package.
+                case 0x9:
+                    break;
+                // Pong package.
+                case 0xa:
+                    break;
+                // Wrong opcode.
+                default :
+                    Worker::safeEcho("error opcode $opcode and close websocket connection. Buffer:" . $buffer . "\n");
+                    $connection->close();
+                    return 0;
+            }
+            // Calculate packet length.
+            if ($data_len === 126) {
+                if (\strlen($buffer) < 4) {
+                    return 0;
+                }
+                $pack = \unpack('nn/ntotal_len', $buffer);
+                $current_frame_length = $pack['total_len'] + 4;
+            } else if ($data_len === 127) {
+                if (\strlen($buffer) < 10) {
+                    return 0;
+                }
+                $arr = \unpack('n/N2c', $buffer);
+                $current_frame_length = $arr['c1']*4294967296 + $arr['c2'] + 10;
+            } else {
+                $current_frame_length = $data_len + 2;
+            }
+
+            $total_package_size = \strlen($connection->websocketDataBuffer) + $current_frame_length;
+            if ($total_package_size > $connection->maxPackageSize) {
+                Worker::safeEcho("error package. package_length=$total_package_size\n");
+                $connection->close();
+                return 0;
+            }
+
+            if ($is_fin_frame) {
+                if ($opcode === 0x9) {
+                    if ($recv_len >= $current_frame_length) {
+                        $ping_data = static::decode(\substr($buffer, 0, $current_frame_length), $connection);
+                        $connection->consumeRecvBuffer($current_frame_length);
+                        $tmp_connection_type = isset($connection->websocketType) ? $connection->websocketType : static::BINARY_TYPE_BLOB;
+                        $connection->websocketType = "\x8a";
+                        if (isset($connection->onWebSocketPing)) {
+                            try {
+                                \call_user_func($connection->onWebSocketPing, $connection, $ping_data);
+                            } catch (\Exception $e) {
+                                Worker::log($e);
+                                exit(250);
+                            } catch (\Error $e) {
+                                Worker::log($e);
+                                exit(250);
+                            }
+                        } else {
+                            $connection->send($ping_data);
+                        }
+                        $connection->websocketType = $tmp_connection_type;
+                        if ($recv_len > $current_frame_length) {
+                            return static::input(\substr($buffer, $current_frame_length), $connection);
+                        }
+                    }
+                    return 0;
+
+                } else if ($opcode === 0xa) {
+                    if ($recv_len >= $current_frame_length) {
+                        $pong_data = static::decode(\substr($buffer, 0, $current_frame_length), $connection);
+                        $connection->consumeRecvBuffer($current_frame_length);
+                        $tmp_connection_type = isset($connection->websocketType) ? $connection->websocketType : static::BINARY_TYPE_BLOB;
+                        $connection->websocketType = "\x8a";
+                        // Try to emit onWebSocketPong callback.
+                        if (isset($connection->onWebSocketPong)) {
+                            try {
+                                \call_user_func($connection->onWebSocketPong, $connection, $pong_data);
+                            } catch (\Exception $e) {
+                                Worker::log($e);
+                                exit(250);
+                            } catch (\Error $e) {
+                                Worker::log($e);
+                                exit(250);
+                            }
+                        }
+                        $connection->websocketType = $tmp_connection_type;
+                        if ($recv_len > $current_frame_length) {
+                            return static::input(\substr($buffer, $current_frame_length), $connection);
+                        }
+                    }
+                    return 0;
+                }
+                return $current_frame_length;
+            } else {
+                $connection->websocketCurrentFrameLength = $current_frame_length;
+            }
+        }
+        // Received just a frame length data.
+        if ($connection->websocketCurrentFrameLength === $recv_len) {
+            self::decode($buffer, $connection);
+            $connection->consumeRecvBuffer($connection->websocketCurrentFrameLength);
+            $connection->websocketCurrentFrameLength = 0;
+            return 0;
+        } // The length of the received data is greater than the length of a frame.
+        elseif ($connection->websocketCurrentFrameLength < $recv_len) {
+            self::decode(\substr($buffer, 0, $connection->websocketCurrentFrameLength), $connection);
+            $connection->consumeRecvBuffer($connection->websocketCurrentFrameLength);
+            $current_frame_length                    = $connection->websocketCurrentFrameLength;
+            $connection->websocketCurrentFrameLength = 0;
+            // Continue to read next frame.
+            return self::input(\substr($buffer, $current_frame_length), $connection);
+        } // The length of the received data is less than the length of a frame.
+        else {
+            return 0;
+        }
+    }
+
+    /**
+     * Websocket encode.
+     *
+     * @param string              $buffer
+     * @param ConnectionInterface $connection
+     * @return string
+     */
+    public static function encode($payload, ConnectionInterface $connection)
+    {
+        if (empty($connection->websocketType)) {
+            $connection->websocketType = self::BINARY_TYPE_BLOB;
+        }
+        $payload = (string)$payload;
+        if (empty($connection->handshakeStep)) {
+            static::sendHandshake($connection);
+        }
+        $mask = 1;
+        $mask_key = "\x00\x00\x00\x00";
+
+        $pack = '';
+        $length = $length_flag = \strlen($payload);
+        if (65535 < $length) {
+            $pack   = \pack('NN', ($length & 0xFFFFFFFF00000000) >> 32, $length & 0x00000000FFFFFFFF);
+            $length_flag = 127;
+        } else if (125 < $length) {
+            $pack   = \pack('n*', $length);
+            $length_flag = 126;
+        }
+
+        $head = ($mask << 7) | $length_flag;
+        $head = $connection->websocketType . \chr($head) . $pack;
+
+        $frame = $head . $mask_key;
+        // append payload to frame:
+        $mask_key = \str_repeat($mask_key, \floor($length / 4)) . \substr($mask_key, 0, $length % 4);
+        $frame .= $payload ^ $mask_key;
+        if ($connection->handshakeStep === 1) {
+            // If buffer has already full then discard the current package.
+            if (\strlen($connection->tmpWebsocketData) > $connection->maxSendBufferSize) {
+                if ($connection->onError) {
+                    try {
+                        \call_user_func($connection->onError, $connection, \WORKERMAN_SEND_FAIL, 'send buffer full and drop package');
+                    } catch (\Exception $e) {
+                        Worker::log($e);
+                        exit(250);
+                    } catch (\Error $e) {
+                        Worker::log($e);
+                        exit(250);
+                    }
+                }
+                return '';
+            }
+            $connection->tmpWebsocketData = $connection->tmpWebsocketData . $frame;
+            // Check buffer is full.
+            if ($connection->maxSendBufferSize <= \strlen($connection->tmpWebsocketData)) {
+                if ($connection->onBufferFull) {
+                    try {
+                        \call_user_func($connection->onBufferFull, $connection);
+                    } catch (\Exception $e) {
+                        Worker::log($e);
+                        exit(250);
+                    } catch (\Error $e) {
+                        Worker::log($e);
+                        exit(250);
+                    }
+                }
+            }
+            return '';
+        }
+        return $frame;
+    }
+
+    /**
+     * Websocket decode.
+     *
+     * @param string              $buffer
+     * @param ConnectionInterface $connection
+     * @return string
+     */
+    public static function decode($bytes, ConnectionInterface $connection)
+    {
+        $data_length = \ord($bytes[1]);
+
+        if ($data_length === 126) {
+            $decoded_data = \substr($bytes, 4);
+        } else if ($data_length === 127) {
+            $decoded_data = \substr($bytes, 10);
+        } else {
+            $decoded_data = \substr($bytes, 2);
+        }
+        if ($connection->websocketCurrentFrameLength) {
+            $connection->websocketDataBuffer .= $decoded_data;
+            return $connection->websocketDataBuffer;
+        } else {
+            if ($connection->websocketDataBuffer !== '') {
+                $decoded_data                    = $connection->websocketDataBuffer . $decoded_data;
+                $connection->websocketDataBuffer = '';
+            }
+            return $decoded_data;
+        }
+    }
+
+    /**
+     * Send websocket handshake data.
+     *
+     * @return void
+     */
+    public static function onConnect($connection)
+    {
+        static::sendHandshake($connection);
+    }
+
+    /**
+     * Clean
+     *
+     * @param $connection
+     */
+    public static function onClose($connection)
+    {
+        $connection->handshakeStep               = null;
+        $connection->websocketCurrentFrameLength = 0;
+        $connection->tmpWebsocketData            = '';
+        $connection->websocketDataBuffer         = '';
+        if (!empty($connection->websocketPingTimer)) {
+            Timer::del($connection->websocketPingTimer);
+            $connection->websocketPingTimer = null;
+        }
+    }
+
+    /**
+     * Send websocket handshake.
+     *
+     * @param TcpConnection $connection
+     * @return void
+     */
+    public static function sendHandshake(TcpConnection $connection)
+    {
+        if (!empty($connection->handshakeStep)) {
+            return;
+        }
+        // Get Host.
+        $port = $connection->getRemotePort();
+        $host = $port === 80 ? $connection->getRemoteHost() : $connection->getRemoteHost() . ':' . $port;
+        // Handshake header.
+        $connection->websocketSecKey = \base64_encode(\md5(\mt_rand(), true));
+        $user_header = isset($connection->headers) ? $connection->headers :
+            (isset($connection->wsHttpHeader) ? $connection->wsHttpHeader : null);
+        $user_header_str = '';
+        if (!empty($user_header)) {
+            if (\is_array($user_header)){
+                foreach($user_header as $k=>$v){
+                    $user_header_str .= "$k: $v\r\n";
+                }
+            } else {
+                $user_header_str .= $user_header;
+            }
+            $user_header_str = "\r\n".\trim($user_header_str);
+        }
+        $header = 'GET ' . $connection->getRemoteURI() . " HTTP/1.1\r\n".
+        (!\preg_match("/\nHost:/i", $user_header_str) ? "Host: $host\r\n" : '').
+        "Connection: Upgrade\r\n".
+        "Upgrade: websocket\r\n".
+        (isset($connection->websocketOrigin) ? "Origin: ".$connection->websocketOrigin."\r\n":'').
+        (isset($connection->WSClientProtocol)?"Sec-WebSocket-Protocol: ".$connection->WSClientProtocol."\r\n":'').
+        "Sec-WebSocket-Version: 13\r\n".
+        "Sec-WebSocket-Key: " . $connection->websocketSecKey . $user_header_str . "\r\n\r\n";
+        $connection->send($header, true);
+        $connection->handshakeStep               = 1;
+        $connection->websocketCurrentFrameLength = 0;
+        $connection->websocketDataBuffer         = '';
+        $connection->tmpWebsocketData            = '';
+    }
+
+    /**
+     * Websocket handshake.
+     *
+     * @param string                              $buffer
+     * @param TcpConnection $connection
+     * @return int
+     */
+    public static function dealHandshake($buffer, TcpConnection $connection)
+    {
+        $pos = \strpos($buffer, "\r\n\r\n");
+        if ($pos) {
+            //checking Sec-WebSocket-Accept
+            if (\preg_match("/Sec-WebSocket-Accept: *(.*?)\r\n/i", $buffer, $match)) {
+                if ($match[1] !== \base64_encode(\sha1($connection->websocketSecKey . "258EAFA5-E914-47DA-95CA-C5AB0DC85B11", true))) {
+                    Worker::safeEcho("Sec-WebSocket-Accept not match. Header:\n" . \substr($buffer, 0, $pos) . "\n");
+                    $connection->close();
+                    return 0;
+                }
+            } else {
+                Worker::safeEcho("Sec-WebSocket-Accept not found. Header:\n" . \substr($buffer, 0, $pos) . "\n");
+                $connection->close();
+                return 0;
+            }
+
+            // handshake complete
+
+            // Get WebSocket subprotocol (if specified by server)
+            if (\preg_match("/Sec-WebSocket-Protocol: *(.*?)\r\n/i", $buffer, $match)) {
+                $connection->WSServerProtocol = \trim($match[1]);
+            }
+
+            $connection->handshakeStep = 2;
+            $handshake_response_length = $pos + 4;
+            // Try to emit onWebSocketConnect callback.
+            if (isset($connection->onWebSocketConnect)) {
+                try {
+                    \call_user_func($connection->onWebSocketConnect, $connection, \substr($buffer, 0, $handshake_response_length));
+                } catch (\Exception $e) {
+                    Worker::log($e);
+                    exit(250);
+                } catch (\Error $e) {
+                    Worker::log($e);
+                    exit(250);
+                }
+            }
+            // Headbeat.
+            if (!empty($connection->websocketPingInterval)) {
+                $connection->websocketPingTimer = Timer::add($connection->websocketPingInterval, function() use ($connection){
+                    if (false === $connection->send(\pack('H*', '898000000000'), true)) {
+                        Timer::del($connection->websocketPingTimer);
+                        $connection->websocketPingTimer = null;
+                    }
+                });
+            }
+
+            $connection->consumeRecvBuffer($handshake_response_length);
+            if (!empty($connection->tmpWebsocketData)) {
+                $connection->send($connection->tmpWebsocketData, true);
+                $connection->tmpWebsocketData = '';
+            }
+            if (\strlen($buffer) > $handshake_response_length) {
+                return self::input(\substr($buffer, $handshake_response_length), $connection);
+            }
+        }
+        return 0;
+    }
+
+    public static function WSSetProtocol($connection, $params) {
+	$connection->WSClientProtocol = $params[0];
+    }
+
+    public static function WSGetServerProtocol($connection) {
+	return (\property_exists($connection, 'WSServerProtocol') ? $connection->WSServerProtocol : null);
+    }
+
+}

app/gateway/vendor/workerman/workerman/README.md

@@ -0,0 +1,386 @@
+# Workerman
+[![Gitter](https://badges.gitter.im/walkor/Workerman.svg)](https://gitter.im/walkor/Workerman?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=body_badge)
+[![Latest Stable Version](https://poser.pugx.org/workerman/workerman/v/stable)](https://packagist.org/packages/workerman/workerman)
+[![Total Downloads](https://poser.pugx.org/workerman/workerman/downloads)](https://packagist.org/packages/workerman/workerman)
+[![Monthly Downloads](https://poser.pugx.org/workerman/workerman/d/monthly)](https://packagist.org/packages/workerman/workerman)
+[![Daily Downloads](https://poser.pugx.org/workerman/workerman/d/daily)](https://packagist.org/packages/workerman/workerman)
+[![License](https://poser.pugx.org/workerman/workerman/license)](https://packagist.org/packages/workerman/workerman)
+
+## What is it
+Workerman is an asynchronous event-driven PHP framework with high performance to build fast and scalable network applications. 
+Workerman supports HTTP, Websocket, SSL and other custom protocols. 
+Workerman supports event extension.
+
+## Requires
+PHP 5.3 or Higher  
+A POSIX compatible operating system (Linux, OSX, BSD)  
+POSIX and PCNTL extensions required   
+Event extension recommended for better performance  
+
+## Installation
+
+```
+composer require workerman/workerman
+```
+
+## Basic Usage
+
+### A websocket server 
+```php
+<?php
+
+use Workerman\Worker;
+
+require_once __DIR__ . '/vendor/autoload.php';
+
+// Create a Websocket server
+$ws_worker = new Worker('websocket://0.0.0.0:2346');
+
+// 4 processes
+$ws_worker->count = 4;
+
+// Emitted when new connection come
+$ws_worker->onConnect = function ($connection) {
+    echo "New connection\n";
+};
+
+// Emitted when data received
+$ws_worker->onMessage = function ($connection, $data) {
+    // Send hello $data
+    $connection->send('Hello ' . $data);
+};
+
+// Emitted when connection closed
+$ws_worker->onClose = function ($connection) {
+    echo "Connection closed\n";
+};
+
+// Run worker
+Worker::runAll();
+```
+
+### An http server
+```php
+use Workerman\Worker;
+
+require_once __DIR__ . '/vendor/autoload.php';
+
+// #### http worker ####
+$http_worker = new Worker('http://0.0.0.0:2345');
+
+// 4 processes
+$http_worker->count = 4;
+
+// Emitted when data received
+$http_worker->onMessage = function ($connection, $request) {
+    //$request->get();
+    //$request->post();
+    //$request->header();
+    //$request->cookie();
+    //$requset->session();
+    //$request->uri();
+    //$request->path();
+    //$request->method();
+
+    // Send data to client
+    $connection->send("Hello World");
+};
+
+// Run all workers
+Worker::runAll();
+```
+
+### A tcp server
+```php
+use Workerman\Worker;
+
+require_once __DIR__ . '/vendor/autoload.php';
+
+// #### create socket and listen 1234 port ####
+$tcp_worker = new Worker('tcp://0.0.0.0:1234');
+
+// 4 processes
+$tcp_worker->count = 4;
+
+// Emitted when new connection come
+$tcp_worker->onConnect = function ($connection) {
+    echo "New Connection\n";
+};
+
+// Emitted when data received
+$tcp_worker->onMessage = function ($connection, $data) {
+    // Send data to client
+    $connection->send("Hello $data \n");
+};
+
+// Emitted when new connection come
+$tcp_worker->onClose = function ($connection) {
+    echo "Connection closed\n";
+};
+
+Worker::runAll();
+```
+
+### Enable SSL
+```php
+<?php
+
+use Workerman\Worker;
+
+require_once __DIR__ . '/vendor/autoload.php';
+
+// SSL context.
+$context = array(
+    'ssl' => array(
+        'local_cert'  => '/your/path/of/server.pem',
+        'local_pk'    => '/your/path/of/server.key',
+        'verify_peer' => false,
+    )
+);
+
+// Create a Websocket server with ssl context.
+$ws_worker = new Worker('websocket://0.0.0.0:2346', $context);
+
+// Enable SSL. WebSocket+SSL means that Secure WebSocket (wss://). 
+// The similar approaches for Https etc.
+$ws_worker->transport = 'ssl';
+
+$ws_worker->onMessage = function ($connection, $data) {
+    // Send hello $data
+    $connection->send('Hello ' . $data);
+};
+
+Worker::runAll();
+```
+
+### Custom protocol
+Protocols/MyTextProtocol.php
+```php
+
+namespace Protocols;
+
+/**
+ * User defined protocol
+ * Format Text+"\n"
+ */
+class MyTextProtocol
+{
+    public static function input($recv_buffer)
+    {
+        // Find the position of the first occurrence of "\n"
+        $pos = strpos($recv_buffer, "\n");
+
+        // Not a complete package. Return 0 because the length of package can not be calculated
+        if ($pos === false) {
+            return 0;
+        }
+
+        // Return length of the package
+        return $pos+1;
+    }
+
+    public static function decode($recv_buffer)
+    {
+        return trim($recv_buffer);
+    }
+
+    public static function encode($data)
+    {
+        return $data . "\n";
+    }
+}
+```
+
+```php
+use Workerman\Worker;
+
+require_once __DIR__ . '/vendor/autoload.php';
+
+// #### MyTextProtocol worker ####
+$text_worker = new Worker('MyTextProtocol://0.0.0.0:5678');
+
+$text_worker->onConnect = function ($connection) {
+    echo "New connection\n";
+};
+
+$text_worker->onMessage = function ($connection, $data) {
+    // Send data to client
+    $connection->send("Hello world\n");
+};
+
+$text_worker->onClose = function ($connection) {
+    echo "Connection closed\n";
+};
+
+// Run all workers
+Worker::runAll();
+```
+
+### Timer
+```php
+
+use Workerman\Worker;
+use Workerman\Timer;
+
+require_once __DIR__ . '/vendor/autoload.php';
+
+$task = new Worker();
+$task->onWorkerStart = function ($task) {
+    // 2.5 seconds
+    $time_interval = 2.5; 
+    $timer_id = Timer::add($time_interval, function () {
+        echo "Timer run\n";
+    });
+};
+
+// Run all workers
+Worker::runAll();
+```
+
+### AsyncTcpConnection (tcp/ws/text/frame etc...)
+```php
+
+use Workerman\Worker;
+use Workerman\Connection\AsyncTcpConnection;
+
+require_once __DIR__ . '/vendor/autoload.php';
+
+$worker = new Worker();
+$worker->onWorkerStart = function () {
+    // Websocket protocol for client.
+    $ws_connection = new AsyncTcpConnection('ws://echo.websocket.org:80');
+    $ws_connection->onConnect = function ($connection) {
+        $connection->send('Hello');
+    };
+    $ws_connection->onMessage = function ($connection, $data) {
+        echo "Recv: $data\n";
+    };
+    $ws_connection->onError = function ($connection, $code, $msg) {
+        echo "Error: $msg\n";
+    };
+    $ws_connection->onClose = function ($connection) {
+        echo "Connection closed\n";
+    };
+    $ws_connection->connect();
+};
+
+Worker::runAll();
+```
+
+
+
+## Available commands
+```php start.php start  ```  
+```php start.php start -d  ```  
+![workerman start](http://www.workerman.net/img/workerman-start.png)  
+```php start.php status  ```  
+![workerman satus](http://www.workerman.net/img/workerman-status.png?a=123)  
+```php start.php connections```  
+```php start.php stop  ```  
+```php start.php restart  ```  
+```php start.php reload  ```  
+
+## Documentation
+
+中文主页:[http://www.workerman.net](http://www.workerman.net)
+
+中文文档: [http://doc.workerman.net](http://doc.workerman.net)
+
+Documentation:[https://github.com/walkor/workerman-manual](https://github.com/walkor/workerman-manual/blob/master/english/src/SUMMARY.md)
+
+# Benchmarks
+```
+CPU:      Intel(R) Core(TM) i3-3220 CPU @ 3.30GHz and 4 processors totally
+Memory:   8G
+OS:       Ubuntu 14.04 LTS
+Software: ab
+PHP:      5.5.9
+```
+
+**Codes**
+```php
+<?php
+use Workerman\Worker;
+
+$worker = new Worker('tcp://0.0.0.0:1234');
+$worker->count = 3;
+$worker->onMessage = function ($connection, $data) {
+    $connection->send("HTTP/1.1 200 OK\r\nConnection: keep-alive\r\nServer: workerman\r\nContent-Length: 5\r\n\r\nhello");
+};
+
+Worker::runAll();
+```
+**Result**
+
+```shell
+ab -n1000000 -c100 -k http://127.0.0.1:1234/
+This is ApacheBench, Version 2.3 <$Revision: 1528965 $>
+Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
+Licensed to The Apache Software Foundation, http://www.apache.org/
+
+Benchmarking 127.0.0.1 (be patient)
+Completed 100000 requests
+Completed 200000 requests
+Completed 300000 requests
+Completed 400000 requests
+Completed 500000 requests
+Completed 600000 requests
+Completed 700000 requests
+Completed 800000 requests
+Completed 900000 requests
+Completed 1000000 requests
+Finished 1000000 requests
+
+
+Server Software:        workerman/3.1.4
+Server Hostname:        127.0.0.1
+Server Port:            1234
+
+Document Path:          /
+Document Length:        5 bytes
+
+Concurrency Level:      100
+Time taken for tests:   7.240 seconds
+Complete requests:      1000000
+Failed requests:        0
+Keep-Alive requests:    1000000
+Total transferred:      73000000 bytes
+HTML transferred:       5000000 bytes
+Requests per second:    138124.14 [#/sec] (mean)
+Time per request:       0.724 [ms] (mean)
+Time per request:       0.007 [ms] (mean, across all concurrent requests)
+Transfer rate:          9846.74 [Kbytes/sec] received
+
+Connection Times (ms)
+              min  mean[+/-sd] median   max
+Connect:        0    0   0.0      0       5
+Processing:     0    1   0.2      1       9
+Waiting:        0    1   0.2      1       9
+Total:          0    1   0.2      1       9
+
+Percentage of the requests served within a certain time (ms)
+  50%      1
+  66%      1
+  75%      1
+  80%      1
+  90%      1
+  95%      1
+  98%      1
+  99%      1
+ 100%      9 (longest request)
+
+```
+
+
+## Other links with workerman
+
+[PHPSocket.IO](https://github.com/walkor/phpsocket.io)   
+[php-socks5](https://github.com/walkor/php-socks5)  
+[php-http-proxy](https://github.com/walkor/php-http-proxy)  
+
+## Donate
+<a href="https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=UQGGS9UB35WWG"><img src="http://donate.workerman.net/img/donate.png"></a>
+
+## LICENSE
+
+Workerman is released under the [MIT license](https://github.com/walkor/workerman/blob/master/MIT-LICENSE.txt).

app/gateway/vendor/workerman/workerman/Timer.php

@@ -0,0 +1,213 @@
+<?php
+/**
+ * This file is part of workerman.
+ *
+ * Licensed under The MIT License
+ * For full copyright and license information, please see the MIT-LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author    walkor<walkor@workerman.net>
+ * @copyright walkor<walkor@workerman.net>
+ * @link      http://www.workerman.net/
+ * @license   http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+namespace Workerman;
+
+use Workerman\Events\EventInterface;
+use Workerman\Worker;
+use \Exception;
+
+/**
+ * Timer.
+ *
+ * example:
+ * Workerman\Timer::add($time_interval, callback, array($arg1, $arg2..));
+ */
+class Timer
+{
+    /**
+     * Tasks that based on ALARM signal.
+     * [
+     *   run_time => [[$func, $args, $persistent, time_interval],[$func, $args, $persistent, time_interval],..]],
+     *   run_time => [[$func, $args, $persistent, time_interval],[$func, $args, $persistent, time_interval],..]],
+     *   ..
+     * ]
+     *
+     * @var array
+     */
+    protected static $_tasks = array();
+
+    /**
+     * event
+     *
+     * @var EventInterface
+     */
+    protected static $_event = null;
+
+    /**
+     * timer id
+     *
+     * @var int
+     */
+    protected static $_timerId = 0;
+
+    /**
+     * timer status
+     * [
+     *   timer_id1 => bool,
+     *   timer_id2 => bool,
+     *   ....................,
+     * ]
+     *
+     * @var array
+     */
+    protected static $_status = array();
+
+    /**
+     * Init.
+     *
+     * @param EventInterface $event
+     * @return void
+     */
+    public static function init($event = null)
+    {
+        if ($event) {
+            self::$_event = $event;
+            return;
+        }
+        if (\function_exists('pcntl_signal')) {
+            \pcntl_signal(\SIGALRM, array('\Workerman\Lib\Timer', 'signalHandle'), false);
+        }
+    }
+
+    /**
+     * ALARM signal handler.
+     *
+     * @return void
+     */
+    public static function signalHandle()
+    {
+        if (!self::$_event) {
+            \pcntl_alarm(1);
+            self::tick();
+        }
+    }
+
+    /**
+     * Add a timer.
+     *
+     * @param float    $time_interval
+     * @param callable $func
+     * @param mixed    $args
+     * @param bool     $persistent
+     * @return int|bool
+     */
+    public static function add($time_interval, $func, $args = array(), $persistent = true)
+    {
+        if ($time_interval <= 0) {
+            Worker::safeEcho(new Exception("bad time_interval"));
+            return false;
+        }
+
+        if ($args === null) {
+            $args = array();
+        }
+
+        if (self::$_event) {
+            return self::$_event->add($time_interval,
+                $persistent ? EventInterface::EV_TIMER : EventInterface::EV_TIMER_ONCE, $func, $args);
+        }
+
+        if (!\is_callable($func)) {
+            Worker::safeEcho(new Exception("not callable"));
+            return false;
+        }
+
+        if (empty(self::$_tasks)) {
+            \pcntl_alarm(1);
+        }
+
+        $run_time = \time() + $time_interval;
+        if (!isset(self::$_tasks[$run_time])) {
+            self::$_tasks[$run_time] = array();
+        }
+
+        self::$_timerId = self::$_timerId == \PHP_INT_MAX ? 1 : ++self::$_timerId;
+        self::$_status[self::$_timerId] = true;
+        self::$_tasks[$run_time][self::$_timerId] = array($func, (array)$args, $persistent, $time_interval);
+
+        return self::$_timerId;
+    }
+
+
+    /**
+     * Tick.
+     *
+     * @return void
+     */
+    public static function tick()
+    {
+        if (empty(self::$_tasks)) {
+            \pcntl_alarm(0);
+            return;
+        }
+        $time_now = \time();
+        foreach (self::$_tasks as $run_time => $task_data) {
+            if ($time_now >= $run_time) {
+                foreach ($task_data as $index => $one_task) {
+                    $task_func     = $one_task[0];
+                    $task_args     = $one_task[1];
+                    $persistent    = $one_task[2];
+                    $time_interval = $one_task[3];
+                    try {
+                        \call_user_func_array($task_func, $task_args);
+                    } catch (\Exception $e) {
+                        Worker::safeEcho($e);
+                    }
+                    if($persistent && !empty(self::$_status[$index])) {
+                        $new_run_time = \time() + $time_interval;
+                        if(!isset(self::$_tasks[$new_run_time])) self::$_tasks[$new_run_time] = array();
+                        self::$_tasks[$new_run_time][$index] = array($task_func, (array)$task_args, $persistent, $time_interval);
+                    }
+                }
+                unset(self::$_tasks[$run_time]);
+            }
+        }
+    }
+
+    /**
+     * Remove a timer.
+     *
+     * @param mixed $timer_id
+     * @return bool
+     */
+    public static function del($timer_id)
+    {
+        if (self::$_event) {
+            return self::$_event->del($timer_id, EventInterface::EV_TIMER);
+        }
+
+        foreach(self::$_tasks as $run_time => $task_data) 
+        {
+            if(array_key_exists($timer_id, $task_data)) unset(self::$_tasks[$run_time][$timer_id]);
+        }
+
+        if(array_key_exists($timer_id, self::$_status)) unset(self::$_status[$timer_id]);
+
+        return true;
+    }
+
+    /**
+     * Remove all timers.
+     *
+     * @return void
+     */
+    public static function delAll()
+    {
+        self::$_tasks = self::$_status = array();
+        \pcntl_alarm(0);
+        if (self::$_event) {
+            self::$_event->clearAllTimer();
+        }
+    }
+}

app/gateway/vendor/workerman/workerman/composer.json

@@ -0,0 +1,38 @@
+{
+    "name": "workerman/workerman",
+    "type": "library",
+    "keywords": [
+        "event-loop",
+        "asynchronous"
+    ],
+    "homepage": "http://www.workerman.net",
+    "license": "MIT",
+    "description": "An asynchronous event driven PHP framework for easily building fast, scalable network applications.",
+    "authors": [
+        {
+            "name": "walkor",
+            "email": "walkor@workerman.net",
+            "homepage": "http://www.workerman.net",
+            "role": "Developer"
+        }
+    ],
+    "support": {
+        "email": "walkor@workerman.net",
+        "issues": "https://github.com/walkor/workerman/issues",
+        "forum": "http://wenda.workerman.net/",
+        "wiki": "http://doc.workerman.net/",
+        "source": "https://github.com/walkor/workerman"
+    },
+    "require": {
+        "php": ">=5.3"
+    },
+    "suggest": {
+        "ext-event": "For better performance. "
+    },
+    "autoload": {
+        "psr-4": {
+            "Workerman\\": "./"
+        }
+    },
+    "minimum-stability": "dev"
+}