You've already forked qlg.tsgz.moe
Init Repo
This commit is contained in:
root
93
vendor/swoole/src/pipe/PipeBase.c
vendored
Executable file
93
vendor/swoole/src/pipe/PipeBase.c
vendored
Executable file
@ -0,0 +1,93 @@
|
||||
/*
|
||||
+----------------------------------------------------------------------+
|
||||
| Swoole |
|
||||
+----------------------------------------------------------------------+
|
||||
| This source file is subject to version 2.0 of the Apache license, |
|
||||
| that is bundled with this package in the file LICENSE, and is |
|
||||
| available through the world-wide-web at the following url: |
|
||||
| http://www.apache.org/licenses/LICENSE-2.0.html |
|
||||
| If you did not receive a copy of the Apache2.0 license and are unable|
|
||||
| to obtain it through the world-wide-web, please send a note to |
|
||||
| license@swoole.com so we can mail you a copy immediately. |
|
||||
+----------------------------------------------------------------------+
|
||||
| Author: Tianfeng Han <mikan.tenny@gmail.com> |
|
||||
+----------------------------------------------------------------------+
|
||||
*/
|
||||
|
||||
#include "swoole.h"
|
||||
|
||||
static int swPipeBase_read(swPipe *p, void *data, int length);
|
||||
static int swPipeBase_write(swPipe *p, void *data, int length);
|
||||
static int swPipeBase_getFd(swPipe *p, int isWriteFd);
|
||||
static int swPipeBase_close(swPipe *p);
|
||||
|
||||
typedef struct _swPipeBase
|
||||
{
|
||||
int pipes[2];
|
||||
} swPipeBase;
|
||||
|
||||
int swPipeBase_create(swPipe *p, int blocking)
|
||||
{
|
||||
int ret;
|
||||
swPipeBase *object = sw_malloc(sizeof(swPipeBase));
|
||||
if (object == NULL)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
p->blocking = blocking;
|
||||
ret = pipe(object->pipes);
|
||||
if (ret < 0)
|
||||
{
|
||||
swWarn("pipe() failed. Error: %s[%d]", strerror(errno), errno);
|
||||
sw_free(object);
|
||||
return -1;
|
||||
}
|
||||
else
|
||||
{
|
||||
//Nonblock
|
||||
swSetNonBlock(object->pipes[0]);
|
||||
swSetNonBlock(object->pipes[1]);
|
||||
p->timeout = -1;
|
||||
p->object = object;
|
||||
p->read = swPipeBase_read;
|
||||
p->write = swPipeBase_write;
|
||||
p->getFd = swPipeBase_getFd;
|
||||
p->close = swPipeBase_close;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int swPipeBase_read(swPipe *p, void *data, int length)
|
||||
{
|
||||
swPipeBase *object = p->object;
|
||||
if (p->blocking == 1 && p->timeout > 0)
|
||||
{
|
||||
if (swSocket_wait(object->pipes[0], p->timeout * 1000, SW_EVENT_READ) < 0)
|
||||
{
|
||||
return SW_ERR;
|
||||
}
|
||||
}
|
||||
return read(object->pipes[0], data, length);
|
||||
}
|
||||
|
||||
static int swPipeBase_write(swPipe *p, void *data, int length)
|
||||
{
|
||||
swPipeBase *this = p->object;
|
||||
return write(this->pipes[1], data, length);
|
||||
}
|
||||
|
||||
static int swPipeBase_getFd(swPipe *p, int isWriteFd)
|
||||
{
|
||||
swPipeBase *this = p->object;
|
||||
return (isWriteFd == 0) ? this->pipes[0] : this->pipes[1];
|
||||
}
|
||||
|
||||
static int swPipeBase_close(swPipe *p)
|
||||
{
|
||||
int ret1, ret2;
|
||||
swPipeBase *this = p->object;
|
||||
ret1 = close(this->pipes[0]);
|
||||
ret2 = close(this->pipes[1]);
|
||||
sw_free(this);
|
||||
return 0 - ret1 - ret2;
|
||||
}
|
||||
142
vendor/swoole/src/pipe/PipeEventfd.c
vendored
Executable file
142
vendor/swoole/src/pipe/PipeEventfd.c
vendored
Executable file
@ -0,0 +1,142 @@
|
||||
/*
|
||||
+----------------------------------------------------------------------+
|
||||
| Swoole |
|
||||
+----------------------------------------------------------------------+
|
||||
| This source file is subject to version 2.0 of the Apache license, |
|
||||
| that is bundled with this package in the file LICENSE, and is |
|
||||
| available through the world-wide-web at the following url: |
|
||||
| http://www.apache.org/licenses/LICENSE-2.0.html |
|
||||
| If you did not receive a copy of the Apache2.0 license and are unable|
|
||||
| to obtain it through the world-wide-web, please send a note to |
|
||||
| license@swoole.com so we can mail you a copy immediately. |
|
||||
+----------------------------------------------------------------------+
|
||||
| Author: Tianfeng Han <mikan.tenny@gmail.com> |
|
||||
+----------------------------------------------------------------------+
|
||||
*/
|
||||
|
||||
#include "swoole.h"
|
||||
|
||||
#ifdef HAVE_EVENTFD
|
||||
#include <sys/eventfd.h>
|
||||
|
||||
static int swPipeEventfd_read(swPipe *p, void *data, int length);
|
||||
static int swPipeEventfd_write(swPipe *p, void *data, int length);
|
||||
static int swPipeEventfd_getFd(swPipe *p, int isWriteFd);
|
||||
static int swPipeEventfd_close(swPipe *p);
|
||||
|
||||
typedef struct _swPipeEventfd
|
||||
{
|
||||
int event_fd;
|
||||
} swPipeEventfd;
|
||||
|
||||
int swPipeEventfd_create(swPipe *p, int blocking, int semaphore, int timeout)
|
||||
{
|
||||
int efd;
|
||||
int flag = 0;
|
||||
swPipeEventfd *object = sw_malloc(sizeof(swPipeEventfd));
|
||||
if (object == NULL)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
flag = EFD_NONBLOCK;
|
||||
|
||||
if (blocking == 1)
|
||||
{
|
||||
if (timeout > 0)
|
||||
{
|
||||
flag = 0;
|
||||
p->timeout = -1;
|
||||
}
|
||||
else
|
||||
{
|
||||
p->timeout = timeout;
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef EFD_SEMAPHORE
|
||||
if (semaphore == 1)
|
||||
{
|
||||
flag |= EFD_SEMAPHORE;
|
||||
}
|
||||
#endif
|
||||
|
||||
p->blocking = blocking;
|
||||
efd = eventfd(0, flag);
|
||||
if (efd < 0)
|
||||
{
|
||||
swWarn("eventfd create failed. Error: %s[%d]", strerror(errno), errno);
|
||||
sw_free(object);
|
||||
return -1;
|
||||
}
|
||||
else
|
||||
{
|
||||
p->object = object;
|
||||
p->read = swPipeEventfd_read;
|
||||
p->write = swPipeEventfd_write;
|
||||
p->getFd = swPipeEventfd_getFd;
|
||||
p->close = swPipeEventfd_close;
|
||||
object->event_fd = efd;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int swPipeEventfd_read(swPipe *p, void *data, int length)
|
||||
{
|
||||
int ret = -1;
|
||||
swPipeEventfd *object = p->object;
|
||||
|
||||
//eventfd not support socket timeout
|
||||
if (p->blocking == 1 && p->timeout > 0)
|
||||
{
|
||||
if (swSocket_wait(object->event_fd, p->timeout * 1000, SW_EVENT_READ) < 0)
|
||||
{
|
||||
return SW_ERR;
|
||||
}
|
||||
}
|
||||
|
||||
while (1)
|
||||
{
|
||||
ret = read(object->event_fd, data, sizeof(uint64_t));
|
||||
if (ret < 0 && errno == EINTR)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
break;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int swPipeEventfd_write(swPipe *p, void *data, int length)
|
||||
{
|
||||
int ret;
|
||||
swPipeEventfd *this = p->object;
|
||||
while (1)
|
||||
{
|
||||
ret = write(this->event_fd, data, sizeof(uint64_t));
|
||||
if (ret < 0)
|
||||
{
|
||||
if (errno == EINTR)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int swPipeEventfd_getFd(swPipe *p, int isWriteFd)
|
||||
{
|
||||
return ((swPipeEventfd *) (p->object))->event_fd;
|
||||
}
|
||||
|
||||
static int swPipeEventfd_close(swPipe *p)
|
||||
{
|
||||
int ret;
|
||||
ret = close(((swPipeEventfd *) (p->object))->event_fd);
|
||||
sw_free(p->object);
|
||||
return ret;
|
||||
}
|
||||
|
||||
#endif
|
||||
135
vendor/swoole/src/pipe/PipeUnsock.c
vendored
Executable file
135
vendor/swoole/src/pipe/PipeUnsock.c
vendored
Executable file
@ -0,0 +1,135 @@
|
||||
/*
|
||||
+----------------------------------------------------------------------+
|
||||
| Swoole |
|
||||
+----------------------------------------------------------------------+
|
||||
| This source file is subject to version 2.0 of the Apache license, |
|
||||
| that is bundled with this package in the file LICENSE, and is |
|
||||
| available through the world-wide-web at the following url: |
|
||||
| http://www.apache.org/licenses/LICENSE-2.0.html |
|
||||
| If you did not receive a copy of the Apache2.0 license and are unable|
|
||||
| to obtain it through the world-wide-web, please send a note to |
|
||||
| license@swoole.com so we can mail you a copy immediately. |
|
||||
+----------------------------------------------------------------------+
|
||||
| Author: Tianfeng Han <mikan.tenny@gmail.com> |
|
||||
+----------------------------------------------------------------------+
|
||||
*/
|
||||
|
||||
#include "swoole.h"
|
||||
|
||||
static int swPipeUnsock_read(swPipe *p, void *data, int length);
|
||||
static int swPipeUnsock_write(swPipe *p, void *data, int length);
|
||||
static int swPipeUnsock_getFd(swPipe *p, int master);
|
||||
static int swPipeUnsock_close(swPipe *p);
|
||||
|
||||
typedef struct _swPipeUnsock
|
||||
{
|
||||
/**
|
||||
* master : socks[1]
|
||||
* worker : socks[0]
|
||||
*/
|
||||
int socks[2];
|
||||
/**
|
||||
* master pipe is closed
|
||||
*/
|
||||
uint8_t pipe_master_closed;
|
||||
/**
|
||||
* worker pipe is closed
|
||||
*/
|
||||
uint8_t pipe_worker_closed;
|
||||
} swPipeUnsock;
|
||||
|
||||
static int swPipeUnsock_getFd(swPipe *p, int master)
|
||||
{
|
||||
swPipeUnsock *this = p->object;
|
||||
return master == 1 ? this->socks[1] : this->socks[0];
|
||||
}
|
||||
|
||||
static int swPipeUnsock_close(swPipe *p)
|
||||
{
|
||||
swPipeUnsock *object = p->object;
|
||||
int ret = swPipeUnsock_close_ext(p, 0);
|
||||
sw_free(object);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int swPipeUnsock_close_ext(swPipe *p, int which)
|
||||
{
|
||||
int ret1 = 0, ret2 = 0;
|
||||
swPipeUnsock *object = p->object;
|
||||
|
||||
if (which == SW_PIPE_CLOSE_MASTER)
|
||||
{
|
||||
if (object->pipe_master_closed)
|
||||
{
|
||||
return SW_ERR;
|
||||
}
|
||||
ret1 = close(object->socks[1]);
|
||||
object->pipe_master_closed = 1;
|
||||
}
|
||||
else if (which == SW_PIPE_CLOSE_WORKER)
|
||||
{
|
||||
if (object->pipe_worker_closed)
|
||||
{
|
||||
return SW_ERR;
|
||||
}
|
||||
ret1 = close(object->socks[0]);
|
||||
object->pipe_worker_closed = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
ret1 = swPipeUnsock_close_ext(p, SW_PIPE_CLOSE_MASTER);
|
||||
ret2 = swPipeUnsock_close_ext(p, SW_PIPE_CLOSE_WORKER);
|
||||
}
|
||||
|
||||
return 0 - ret1 - ret2;
|
||||
}
|
||||
|
||||
int swPipeUnsock_create(swPipe *p, int blocking, int protocol)
|
||||
{
|
||||
int ret;
|
||||
swPipeUnsock *object = sw_malloc(sizeof(swPipeUnsock));
|
||||
if (object == NULL)
|
||||
{
|
||||
swWarn("malloc() failed.");
|
||||
return SW_ERR;
|
||||
}
|
||||
bzero(object, sizeof(swPipeUnsock));
|
||||
p->blocking = blocking;
|
||||
ret = socketpair(AF_UNIX, protocol, 0, object->socks);
|
||||
if (ret < 0)
|
||||
{
|
||||
swWarn("socketpair() failed. Error: %s [%d]", strerror(errno), errno);
|
||||
sw_free(object);
|
||||
return SW_ERR;
|
||||
}
|
||||
else
|
||||
{
|
||||
//Nonblock
|
||||
if (blocking == 0)
|
||||
{
|
||||
swSetNonBlock(object->socks[0]);
|
||||
swSetNonBlock(object->socks[1]);
|
||||
}
|
||||
|
||||
int sbsize = SwooleG.socket_buffer_size;
|
||||
swSocket_set_buffer_size(object->socks[0], sbsize);
|
||||
swSocket_set_buffer_size(object->socks[1], sbsize);
|
||||
|
||||
p->object = object;
|
||||
p->read = swPipeUnsock_read;
|
||||
p->write = swPipeUnsock_write;
|
||||
p->getFd = swPipeUnsock_getFd;
|
||||
p->close = swPipeUnsock_close;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int swPipeUnsock_read(swPipe *p, void *data, int length)
|
||||
{
|
||||
return read(((swPipeUnsock *) p->object)->socks[0], data, length);
|
||||
}
|
||||
|
||||
static int swPipeUnsock_write(swPipe *p, void *data, int length)
|
||||
{
|
||||
return write(((swPipeUnsock *) p->object)->socks[1], data, length);
|
||||
}
|
||||
Reference in New Issue
Block a user