/**
* Initialize a new stream listener
*/
public function __construct($stream)
{
$this->stream = $stream;
stream_set_blocking($this->stream, 0);
$this->event = event_buffer_new($this->stream, array($this, '_read'), array($this, '_write'), array($this, '_error'));
Loop::attachBuffer($this);
event_buffer_timeout_set($this->event, 2, 5);
event_buffer_watermark_set($this->event, EV_READ, 0, 0xffffff);
event_buffer_priority_set($this->event, 10);
event_buffer_enable($this->event, EV_READ | EV_PERSIST);
}
protected function addClient($socket, $flag, $base)
{
$connection = stream_socket_accept($socket);
stream_set_blocking($connection, 0);
$id = md5(time() . rand() . $flag);
$client = new $this->client_type($this, $id, $connection);
$buffer = event_buffer_new($connection, [$this, 'read'], NULL, [$this, 'error'], $client);
event_buffer_base_set($buffer, $base);
event_buffer_timeout_set($buffer, self::CONNECTION_TIMEOUT, self::CONNECTION_TIMEOUT);
event_buffer_watermark_set($buffer, EV_READ, 0, 0xffffff);
event_buffer_priority_set($buffer, self::EVENT_PRIORITY);
event_buffer_enable($buffer, EV_READ | EV_PERSIST);
$client->setBuffer($buffer);
}
public function accept($socket, $flag, $base)
{
Logger::getInstance()->outDebug("Try to accept new connection.");
$this->id++;
$connection = stream_socket_accept($socket);
stream_set_blocking($connection, 0);
$buffer = event_buffer_new($connection, array($this, 'onRead'), NULL, array($this, 'onError'), $this->id);
event_buffer_base_set($buffer, $this->base);
event_buffer_timeout_set($buffer, 180, 180);
event_buffer_watermark_set($buffer, EV_READ, 0, 0xffffff);
event_buffer_priority_set($buffer, 10);
event_buffer_enable($buffer, EV_READ | EV_PERSIST);
$this->connections[$this->id] = $connection;
$this->buffers[$this->id] = $buffer;
}
function ev_accept($socket, $flag, $base)
{
static $id = 0;
$connection = stream_socket_accept($socket);
stream_set_blocking($connection, 0);
$id += 1;
$buffer = event_buffer_new($connection, 'ev_read', NULL, 'ev_error', $id);
event_buffer_base_set($buffer, $base);
event_buffer_timeout_set($buffer, 30, 30);
event_buffer_watermark_set($buffer, EV_READ, 0, 0xffffff);
event_buffer_priority_set($buffer, 10);
event_buffer_enable($buffer, EV_READ | EV_PERSIST);
// we need to save both buffer and connection outside
$GLOBALS['connections'][$id] = $connection;
$GLOBALS['buffers'][$id] = $buffer;
}
function ev_accept($socket, $flag, $base)
{
static $id = 0;
$connection = stream_socket_accept($socket);
stream_set_blocking($connection, 0);
$id++;
// increase on each accept
$buffer = event_buffer_new($connection, array(__CLASS__, 'ev_read'), array(__CLASS__, 'ev_write'), array(__CLASS__, 'ev_error'), $id);
event_buffer_base_set($buffer, $base);
event_buffer_timeout_set($buffer, 30, 30);
event_buffer_watermark_set($buffer, EV_READ, 0, 0xffffff);
event_buffer_priority_set($buffer, 10);
event_buffer_enable($buffer, EV_READ | EV_PERSIST);
// we need to save both buffer and connection outside
self::$connections[$id] = $connection;
self::$buffers[$id] = $buffer;
}
public function ev_accept($socket, $flag, $base)
{
static $id = 0;
// stream_socket_accept — 接受由 stream_socket_server() 创建的套接字连接
$connection = stream_socket_accept($socket);
stream_set_blocking($connection, 0);
$id++;
// event_buffer_new — Create new buffered event
$buffer = event_buffer_new($connection, [__CLASS__, 'ev_read'], [__CLASS__, 'ev_write'], [__CLASS__, 'ev_error'], $id);
// event_buffer_base_set — Associate buffered event with an event base
event_buffer_base_set($buffer, $base);
// event_buffer_timeout_set — Set read and write timeouts for a buffered event
event_buffer_timeout_set($buffer, 30, 30);
// event_buffer_watermark_set — Set the watermarks for read and write events
event_buffer_watermark_set($buffer, EV_READ, 0, 0xffffff);
// event_buffer_priority_set — Assign a priority to a buffered event
event_buffer_priority_set($buffer, 10);
// event_buffer_enable — Enable a buffered event
event_buffer_enable($buffer, EV_READ | EV_PERSIST);
self::$connections[$id] = $connection;
self::$buffers[$id] = $buffer;
}
protected function addConnectionBuffer($conn_num)
{
$buffer = event_buffer_new($this->connections[$conn_num], array($this, 'onEventRead'), array($this, 'onEventWrite'), array($this, 'onEventError'), array($conn_num));
event_buffer_base_set($buffer, $this->event_base);
event_buffer_timeout_set($buffer, $this->timeout, $this->timeout);
event_buffer_enable($buffer, EV_READ | EV_WRITE | EV_PERSIST);
self::log('Connection', $conn_num, 'buffer added');
$this->connection_buffers[$conn_num] = $buffer;
$this->connection_statuses[$conn_num] = self::STATE_READ;
}
private function monitor($conn, $buffer)
{
event_buffer_set_callback($buffer, [$this, 'readcb'], null, [$this, 'errorcb'], $conn);
event_buffer_timeout_set($buffer, 1200, 1200);
event_buffer_watermark_set($buffer, EV_READ, 1, null);
event_buffer_enable($buffer, EV_READ | EV_PERSIST | EVLOOP_NONBLOCK);
unset($this->unauthorized[(int) $conn]);
$this->buffers[(int) $conn] = $buffer;
}
public function ev_accept($socket, $flag, $argument)
{
$this->log("ev_accept(..., {$flag}, ...)");
$to = ini_get("default_socket_timeout");
$connection = stream_socket_accept($socket, $to, $peer);
stream_set_blocking($connection, 0);
$readCb = array($this, 'ev_read');
$writeCb = array($this, 'ev_write');
$errCb = array($this, 'ev_error');
$id = uniqid();
$buffer = event_buffer_new($connection, $readCb, $writeCb, $errCb, $id);
event_buffer_base_set($buffer, $this->base);
event_buffer_timeout_set($buffer, self::TIMEOUT_SECONDS, self::TIMEOUT_SECONDS);
event_buffer_watermark_set($buffer, EV_READ, 0, 0xffffff);
event_buffer_priority_set($buffer, 10);
event_buffer_enable($buffer, EV_READ | EV_PERSIST);
$this->fire('connection', $connection);
$request = new ServerRequest($this->base);
$request->client_id = $id;
$request->server = $this;
$request->connection = $connection;
$request->ev_buffer = $buffer;
$request->peer = $peer;
$response = new ServerResponse($request);
$response->client_id = $id;
$response->server = $this;
$response->connection = $connection;
$response->ev_buffer = $buffer;
$this->clients[$id] = array('socket' => $connection, 'buffer' => $buffer, 'request' => $request, 'response' => $response, 'disconnect' => false);
}
/**
* Sets the read and write timeout
*
* If one argument is supplied, it will be used as both the read and write
* timeout. If two arguments are supplied, the first is the read, the
* second is the write timeout.
*
* @param int $readTimeOut
* @param int $writeTimeOut
* @return void
*/
public function setTimeout($readTimeOut, $writeTimeOut = null)
{
event_buffer_timeout_set($this->resource, $readTimeOut, is_null($writeTimeOut) ? $readTimeOut : $writeTimeOut);
}
public function setFd($fd)
{
$this->fd = $fd;
if ($this->directInput || $this->directOutput) {
$ev = event_new();
$flags = 0;
if ($this->directInput) {
$flags |= EV_READ;
}
if ($this->directOutput) {
$flags |= EV_WRITE;
}
if ($this->timeout !== null) {
$flags |= EV_TIMEOUT;
}
event_set($ev, $this->fd, $flags | EV_PERSIST, array($this, 'onDirectEvent'));
event_base_set($ev, Daemon::$process->eventBase);
if ($this->priority !== null) {
event_priority_set($ev, $this->priority);
}
if ($this->timeout !== null) {
event_add($ev, 1000000.0 * $this->timeout);
} else {
event_add($ev);
}
$this->event = $ev;
}
if (!$this->directOutput || !$this->directOutput) {
$this->buffer = event_buffer_new($this->fd, $this->directInput ? null : array($this, 'onReadEvent'), $this->directOutput ? null : array($this, 'onWriteEvent'), array($this, 'onFailureEvent'));
event_buffer_base_set($this->buffer, Daemon::$process->eventBase);
if ($this->priority !== null) {
event_buffer_priority_set($this->buffer, $this->priority);
}
if ($this->timeout) {
event_buffer_timeout_set($this->buffer, $this->timeout, $this->timeout);
}
if (!$this->directInput) {
event_buffer_watermark_set($this->buffer, EV_READ, $this->lowMark, $this->highMark);
}
event_buffer_enable($this->buffer, $this->directInput ? EV_WRITE | EV_TIMEOUT | EV_PERSIST : EV_READ | EV_WRITE | EV_TIMEOUT | EV_PERSIST);
}
if (!$this->inited) {
$this->inited = true;
$this->init();
}
}
/**
* Obsluga nowych polaczen
* @param resource (stream) $pSock socket wykorzystywany do komunikacji
* @param int $pFlag flaga okreslajaca zdarzenie
* {EV_TIMEOUT, EV_SIGNAL, EV_READ, EV_WRITE, EV_PERSIST}
* @param resource (event base) $pBase zdarzenie bazowe
* @return boolean czy obsluzono nowe polaczenie
*/
private function onConnection($pSock, $pFlag, $pBase)
{
// jesli za duzo polaczen, czekamy az beda jakies dostepne
if (count($this->connections) == $this->maxConnections) {
return false;
}
// unikalny identyfikator polaczenia
static $connection_id = 0;
$connection_id++;
$sock = stream_socket_accept($pSock);
stream_set_blocking($sock, 0);
$buffer = event_buffer_new($sock, [$this, 'onRead'], null, [$this, 'onError'], $connection_id);
event_buffer_base_set($buffer, $pBase);
if ($this->timeout > 0) {
event_buffer_timeout_set($buffer, $this->timeout, $this->timeout);
}
event_buffer_watermark_set($buffer, EV_READ, 0, 0xffffff);
event_buffer_enable($buffer, EV_READ | EV_PERSIST);
$connection = new DaemonConnection($connection_id, $sock);
$connection->setEventBuffer($buffer);
$this->setConnection($connection);
$this->log("New connection (id = " . $connection_id . ")...");
return true;
}
private function return_response($request_id, $response_message)
{
if (array_key_exists($request_id, $this->requests_working)) {
$length = strlen($response_message);
$event = $this->requests_working[$request_id];
event_buffer_disable($event, EV_READ | EV_WRITE);
event_buffer_watermark_set($event, EV_WRITE, 0, 0);
event_buffer_timeout_set($event, 1, 1);
event_buffer_set_callback($event, null, array($this, 'close_request'), array($this, 'return_response_error'), $request_id);
event_buffer_enable($event, EV_WRITE);
$header = pack('N', $length);
event_buffer_write($event, $header . $response_message);
unset($this->requests_assigned[$request_id]);
}
}
/**
* 添加事件
* @see BaseEvent::add()
*/
public function add($fd, $flag, $func, $args = null, $read_timeout = 1000, $write_timeout = 1000)
{
$event_key = (int) $fd;
$real_flag = EV_READ | EV_PERSIST;
switch ($flag) {
// 链接事件
case self::EV_ACCEPT:
break;
// 数据可读事件
// 数据可读事件
case self::EV_READ:
$this->eventBuffer[$event_key] = event_buffer_new($fd, array($this, 'bufferCallBack'), NULL, array($this, 'bufferCallBackErr'), array('args' => $args, 'func' => $func, 'fd' => $fd));
event_buffer_base_set($this->eventBuffer[$event_key], $this->eventBase);
event_buffer_timeout_set($this->eventBuffer[$event_key], ceil($read_timeout / 1000), ceil($write_timeout / 1000));
event_buffer_watermark_set($this->eventBuffer[$event_key], EV_READ, 0, 0xffffff);
// event_buffer_priority_set($this->eventBuffer[$event_key], 10);
event_buffer_enable($this->eventBuffer[$event_key], EV_READ | EV_PERSIST);
return true;
// 数据可写事件,这个事件目前没有用到
// 数据可写事件,这个事件目前没有用到
case self::EV_WRITE:
$real_flag = EV_WRITE | EV_PERSIST;
break;
// 信号监听事件
// 信号监听事件
case self::EV_SIGNAL:
$real_flag = EV_SIGNAL | EV_PERSIST;
// 创建一个用于监听的event
$this->eventSignal[$event_key] = event_new();
// 设置监听处理函数
if (!event_set($this->eventSignal[$event_key], $fd, $real_flag, $func, $args)) {
return false;
}
// 设置event base
if (!event_base_set($this->eventSignal[$event_key], $this->eventBase)) {
return false;
}
// 添加事件
if (!event_add($this->eventSignal[$event_key])) {
return false;
}
return true;
break;
// 监控文件描述符可读事件
// 监控文件描述符可读事件
case self::EV_NOINOTIFY:
$real_flag = EV_READ | EV_PERSIST;
break;
}
// 创建一个用于监听的event
$this->allEvents[$event_key][$flag] = event_new();
// 设置监听处理函数
if (!event_set($this->allEvents[$event_key][$flag], $fd, $real_flag, $func, $args)) {
return false;
}
// 设置event base
if (!event_base_set($this->allEvents[$event_key][$flag], $this->eventBase)) {
return false;
}
// 添加事件
if (!event_add($this->allEvents[$event_key][$flag])) {
return false;
}
return true;
}
/**
* Sets the read and write timeouts for the specified buffered event.
*
* @see event_buffer_timeout_set
*
* @throws EventException
*
* @param int $read_timeout Read timeout (in seconds).
* @param int $write_timeout Write timeout (in seconds).
*
* @return EventBuffer
*/
public function setTimout($read_timeout = self::DEFAULT_TIMEOUT_READ, $write_timeout = self::DEFAULT_TIMEOUT_WRITE)
{
event_buffer_timeout_set($this->resource, $read_timeout, $write_timeout);
return $this;
}
/**
*
* @param array $Headers
* @return boolean return true if this is a comet request.
*/
private function ProcessRequest($Headers)
{
$Request = $Headers['_Request_'];
switch ($Request['Method']) {
case 'GET':
case 'POST':
case 'PUT':
case 'DELETE':
if (preg_match('/^\\/comet\\/?/i', $Request['File'])) {
event_buffer_timeout_set($this->BufferEvent, $this->Config['ClientSocketTTL'], $this->Config['ClientTransTimeout']);
$this->Expire = time() + $this->Config['ClientSocketTTL'];
event_buffer_write($this->BufferEvent, self::ChunkDataHeader);
return true;
}
break;
default:
$this->Shutdown(false);
return false;
}
$this->OutputFile($Headers);
return false;
}
/**
* Handle new connection events. Add new clients to the list. The server will write a welcome message to each client
* Sets the following functions to handle I/O events
* 'ev_read()', 'ev_write()', 'ev_error()'
*
* @param $socket resource
* @param $flag int A flag indicating the event. Consists of the following flags: EV_TIMEOUT, EV_SIGNAL, EV_READ, EV_WRITE and EV_PERSIST.
* @param $base resource created by event_base_new()
*/
function ev_accept($socket, $flag, $base)
{
global $clients;
static $next_id = 0;
$connection = stream_socket_accept($socket);
stream_set_blocking($connection, 0);
$next_id++;
$buffer = event_buffer_new($connection, 'ev_read', 'ev_write', 'ev_error', $next_id);
event_buffer_base_set($buffer, $base);
event_buffer_timeout_set($buffer, GSMTP_TIMEOUT, GSMTP_TIMEOUT);
event_buffer_watermark_set($buffer, EV_READ, 0, 0xffffff);
event_buffer_priority_set($buffer, 10);
event_buffer_enable($buffer, EV_READ | EV_PERSIST);
$clients[$next_id]['socket'] = $connection;
// new socket
$clients[$next_id]['ev_buffer'] = $buffer;
// new socket
$clients[$next_id]['state'] = 0;
$clients[$next_id]['mail_from'] = '';
$clients[$next_id]['helo'] = '';
$clients[$next_id]['rcpt_to'] = '';
$clients[$next_id]['error_c'] = 0;
$clients[$next_id]['read_buffer'] = '';
$clients[$next_id]['read_buffer_ready'] = false;
// true if the buffer is ready to be fetched
$clients[$next_id]['response'] = '';
// response messages are placed here, before they go on the write buffer
$clients[$next_id]['time'] = time();
$address = stream_socket_get_name($clients[$next_id]['socket'], true);
$clients[$next_id]['address'] = $address;
process_smtp($next_id);
if (strlen($clients[$next_id]['response']) > 0) {
event_buffer_write($buffer, $clients[$next_id]['response']);
add_response($next_id, null);
}
}
