static int swPort_onRead_check_eof(swReactor *reactor, swListenPort *port, swEvent *event)
{
swServer *serv = SwooleG.serv;
swConnection *conn = swServer_connection_get(serv, event->fd);
swProtocol *protocol = &port->protocol;
#ifdef SW_USE_OPENSSL
if (swPort_check_ssl_state(port, conn) < 0)
{
return swReactorThread_onClose(reactor, event);
}
#endif
if (conn->object == NULL)
{
conn->object = swString_new(SW_BUFFER_SIZE);
//alloc memory failed.
if (!conn->object)
{
return SW_ERR;
}
}
if (swProtocol_recv_check_eof(protocol, conn, conn->object) < 0)
{
swReactorThread_onClose(reactor, event);
}
return SW_OK;
}
static int swPort_onRead_raw(swReactor *reactor, swListenPort *port, swEvent *event)
{
int ret = 0, n;
swServer *serv = reactor->ptr;
swDispatchData task;
swConnection *conn = swServer_connection_get(serv, event->fd);
#ifdef SW_USE_OPENSSL
if (swPort_check_ssl_state(port, conn) < 0)
{
goto close_fd;
}
#endif
n = swConnection_recv(conn, task.data.data, SW_BUFFER_SIZE, 0);
if (n < 0)
{
switch (swConnection_error(errno))
{
case SW_ERROR:
swSysError("recv from connection#%d failed.", event->fd);
return SW_OK;
case SW_CLOSE:
goto close_fd;
default:
return SW_OK;
}
}
else if (n == 0)
{
close_fd: swReactorThread_onClose(reactor, event);
return SW_OK;
}
else
{
conn->last_time = SwooleGS->now;
task.data.info.fd = event->fd;
task.data.info.from_id = event->from_id;
task.data.info.len = n;
task.data.info.type = SW_EVENT_TCP;
task.target_worker_id = -1;
#ifdef SW_USE_RINGBUFFER
if (serv->factory_mode == SW_MODE_PROCESS)
{
ret = swReactorThread_dispatch(conn, task.data.data, task.data.info.len);
}
else
#else
{
ret = serv->factory.dispatch(&serv->factory, &task);
}
#endif
return ret;
}
return SW_OK;
}
static int swPort_onRead_check_eof(swReactor *reactor, swListenPort *port, swEvent *event)
{
swConnection *conn = event->socket;
swProtocol *protocol = &port->protocol;
swServer *serv = reactor->ptr;
swString *buffer = swServer_get_buffer(serv, event->fd);
if (!buffer)
{
return SW_ERR;
}
if (swProtocol_recv_check_eof(protocol, conn, buffer) < 0)
{
swReactorThread_onClose(reactor, event);
}
return SW_OK;
}
static int swPort_onRead_raw(swReactor *reactor, swListenPort *port, swEvent *event)
{
int n;
swDispatchData task;
swConnection *conn = event->socket;
n = swConnection_recv(conn, task.data.data, SW_BUFFER_SIZE, 0);
if (n < 0)
{
switch (swConnection_error(errno))
{
case SW_ERROR:
swSysError("recv from connection#%d failed.", event->fd);
return SW_OK;
case SW_CLOSE:
conn->close_errno = errno;
goto close_fd;
default:
return SW_OK;
}
}
else if (n == 0)
{
close_fd: swReactorThread_onClose(reactor, event);
return SW_OK;
}
else
{
task.data.info.fd = event->fd;
task.data.info.from_id = event->from_id;
task.data.info.len = n;
task.data.info.type = SW_EVENT_TCP;
task.target_worker_id = -1;
return swReactorThread_dispatch(conn, task.data.data, task.data.info.len);
}
return SW_OK;
}
/**
* For Http Protocol
*/
static int swPort_onRead_http(swReactor *reactor, swListenPort *port, swEvent *event)
{
swConnection *conn = event->socket;
if (conn->websocket_status >= WEBSOCKET_STATUS_HANDSHAKE)
{
if (conn->http_upgrade == 0)
{
swHttpRequest_free(conn);
conn->websocket_status = WEBSOCKET_STATUS_ACTIVE;
conn->http_upgrade = 1;
}
return swPort_onRead_check_length(reactor, port, event);
}
#ifdef SW_USE_HTTP2
if (conn->http2_stream)
{
return swPort_onRead_check_length(reactor, port, event);
}
#endif
int n = 0;
char *buf;
int buf_len;
swHttpRequest *request = NULL;
swProtocol *protocol = &port->protocol;
//new http request
if (conn->object == NULL)
{
request = sw_malloc(sizeof(swHttpRequest));
bzero(request, sizeof(swHttpRequest));
conn->object = request;
}
else
{
request = (swHttpRequest *) conn->object;
}
if (!request->buffer)
{
request->buffer = swString_new(SW_HTTP_HEADER_MAX_SIZE);
//alloc memory failed.
if (!request->buffer)
{
swReactorThread_onClose(reactor, event);
return SW_ERR;
}
}
swString *buffer = request->buffer;
recv_data:
buf = buffer->str + buffer->length;
buf_len = buffer->size - buffer->length;
n = swConnection_recv(conn, buf, buf_len, 0);
if (n < 0)
{
switch (swConnection_error(errno))
{
case SW_ERROR:
swSysError("recv from connection#%d failed.", event->fd);
return SW_OK;
case SW_CLOSE:
conn->close_errno = errno;
goto close_fd;
default:
return SW_OK;
}
}
else if (n == 0)
{
close_fd:
swHttpRequest_free(conn);
swReactorThread_onClose(reactor, event);
return SW_OK;
}
else
{
buffer->length += n;
if (request->method == 0 && swHttpRequest_get_protocol(request) < 0)
{
if (request->buffer->length < SW_HTTP_HEADER_MAX_SIZE)
{
return SW_OK;
}
swWarn("get protocol failed.");
#ifdef SW_HTTP_BAD_REQUEST
if (swConnection_send(conn, SW_STRL(SW_HTTP_BAD_REQUEST) - 1, 0) < 0)
{
swSysError("send() failed.");
}
#endif
goto close_fd;
}
if (request->method > HTTP_PRI)
{
swWarn("method no support");
goto close_fd;
}
#ifdef SW_USE_HTTP2
else if (request->method == HTTP_PRI)
{
conn->http2_stream = 1;
swHttp2_send_setting_frame(protocol, conn);
if (n == sizeof(SW_HTTP2_PRI_STRING) - 1)
{
swHttpRequest_free(conn);
return SW_OK;
}
swHttp2_parse_frame(protocol, conn, buf + (sizeof(SW_HTTP2_PRI_STRING) - 1), n - (sizeof(SW_HTTP2_PRI_STRING) - 1));
swHttpRequest_free(conn);
return SW_OK;
}
#endif
if (request->content_length == 0)
{
if (swHttpRequest_get_content_length(request) < 0)
{
if (memcmp(buffer->str + buffer->length - 4, "\r\n\r\n", 4) == 0)
{
swReactorThread_dispatch(conn, buffer->str, buffer->length);
swHttpRequest_free(conn);
return SW_OK;
}
else if (buffer->size == buffer->length)
{
swWarn("[0]http header is too long.");
goto close_fd;
}
//wait more data
else
{
goto recv_data;
}
}
else if (request->content_length > (protocol->package_max_length - SW_HTTP_HEADER_MAX_SIZE))
{
swWarn("Content-Length is too big, MaxSize=[%d].", protocol->package_max_length - SW_HTTP_HEADER_MAX_SIZE);
goto close_fd;
}
}
//http header is not the end
if (request->header_length == 0)
{
if (swHttpRequest_get_header_length(request) < 0)
{
if (buffer->size == buffer->length)
{
swWarn("[2]http header is too long.");
goto close_fd;
}
else
{
goto recv_data;
}
}
}
//total length
uint32_t request_size = request->content_length + request->header_length;
if (request_size > buffer->size && swString_extend(buffer, request_size) < 0)
{
goto close_fd;
}
//discard the redundant data
if (buffer->length > request_size)
{
buffer->length = request_size;
}
if (buffer->length == request_size)
{
swReactorThread_dispatch(conn, buffer->str, buffer->length);
swHttpRequest_free(conn);
}
else
{
#ifdef SW_HTTP_100_CONTINUE
//Expect: 100-continue
if (swHttpRequest_has_expect_header(request))
{
swSendData _send;
_send.data = "HTTP/1.1 100 Continue\r\n\r\n";
_send.length = strlen(_send.data);
int send_times = 0;
direct_send:
n = swConnection_send(conn, _send.data, _send.length, 0);
if (n < _send.length)
{
_send.data += n;
_send.length -= n;
send_times++;
if (send_times < 10)
{
goto direct_send;
}
else
{
swWarn("send http header failed");
}
}
}
else
{
swTrace("PostWait: request->content_length=%d, buffer->length=%zd, request->header_length=%d\n",
request->content_length, buffer->length, request->header_length);
}
#endif
goto recv_data;
}
}
return SW_OK;
}
/**
* For Http Protocol
*/
static int swPort_onRead_http(swReactor *reactor, swListenPort *port, swEvent *event)
{
swConnection *conn = event->socket;
swServer *serv = reactor->ptr;
if (conn->websocket_status >= WEBSOCKET_STATUS_HANDSHAKE)
{
if (conn->http_upgrade == 0)
{
swHttpRequest_free(conn);
conn->websocket_status = WEBSOCKET_STATUS_ACTIVE;
conn->http_upgrade = 1;
}
return swPort_onRead_check_length(reactor, port, event);
}
#ifdef SW_USE_HTTP2
if (conn->http2_stream)
{
_parse_frame: return swPort_onRead_check_length(reactor, port, event);
}
#endif
int n = 0;
char *buf;
int buf_len;
swHttpRequest *request = NULL;
swProtocol *protocol = &port->protocol;
//new http request
if (conn->object == NULL)
{
request = sw_malloc(sizeof(swHttpRequest));
bzero(request, sizeof(swHttpRequest));
conn->object = request;
}
else
{
request = (swHttpRequest *) conn->object;
}
if (!request->buffer)
{
request->buffer = swString_new(SW_HTTP_HEADER_MAX_SIZE);
//alloc memory failed.
if (!request->buffer)
{
swReactorThread_onClose(reactor, event);
return SW_ERR;
}
}
swString *buffer = request->buffer;
recv_data:
buf = buffer->str + buffer->length;
buf_len = buffer->size - buffer->length;
n = swConnection_recv(conn, buf, buf_len, 0);
if (n < 0)
{
switch (swConnection_error(errno))
{
case SW_ERROR:
swSysError("recv from connection#%d failed.", event->fd);
return SW_OK;
case SW_CLOSE:
conn->close_errno = errno;
goto close_fd;
default:
return SW_OK;
}
}
else if (n == 0)
{
close_fd:
swHttpRequest_free(conn);
swReactorThread_onClose(reactor, event);
return SW_OK;
}
else
{
buffer->length += n;
if (request->method == 0 && swHttpRequest_get_protocol(request) < 0)
{
if (request->excepted == 0 && request->buffer->length < SW_HTTP_HEADER_MAX_SIZE)
{
return SW_OK;
}
swoole_error_log(SW_LOG_TRACE, SW_ERROR_HTTP_INVALID_PROTOCOL, "get protocol failed.");
#ifdef SW_HTTP_BAD_REQUEST_TIP
if (swConnection_send(conn, SW_STRL(SW_HTTP_BAD_REQUEST_TIP), 0) < 0)
{
swSysError("send() failed.");
}
#endif
goto close_fd;
}
if (request->method > HTTP_PRI)
{
swWarn("method no support");
goto close_fd;
}
#ifdef SW_USE_HTTP2
else if (request->method == HTTP_PRI)
{
conn->http2_stream = 1;
swHttp2_send_setting_frame(protocol, conn);
if (n == sizeof(SW_HTTP2_PRI_STRING) - 1)
{
swHttpRequest_free(conn);
return SW_OK;
}
swString *buffer = swServer_get_buffer(serv, event->fd);
if (!buffer)
{
goto close_fd;
}
swString_append_ptr(buffer, buf + (sizeof(SW_HTTP2_PRI_STRING) - 1), n - (sizeof(SW_HTTP2_PRI_STRING) - 1));
swHttpRequest_free(conn);
conn->skip_recv = 1;
goto _parse_frame;
}
#endif
//http header is not the end
if (request->header_length == 0)
{
if (swHttpRequest_get_header_length(request) < 0)
{
if (buffer->size == buffer->length)
{
swWarn("[2]http header is too long.");
goto close_fd;
}
else
{
goto recv_data;
}
}
}
//http body
if (request->content_length == 0)
{
swTraceLog(SW_TRACE_SERVER, "content-length=%u, keep-alive=%d", request->content_length, request->keep_alive);
// content length field not found
if (swHttpRequest_get_header_info(request) < 0)
{
/* the request is really no body */
if (buffer->length == request->header_length)
{
/**
* send static file content directly in the reactor thread
*/
if (!(serv->enable_static_handler && swPort_http_static_handler(request, conn)))
{
/**
* dynamic request, dispatch to worker
*/
swReactorThread_dispatch(conn, buffer->str, buffer->length);
}
swHttpRequest_free(conn);
return SW_OK;
}
else if (buffer->size == buffer->length)
{
swWarn("[0]http header is too long.");
goto close_fd;
}
/* wait more data */
else
{
goto recv_data;
}
}
else if (request->content_length > (protocol->package_max_length - request->header_length))
{
swWarn("Content-Length is too big, MaxSize=[%d].", protocol->package_max_length - request->header_length);
goto close_fd;
}
}
//total length
uint32_t request_size = request->header_length + request->content_length;
if (request_size > buffer->size && swString_extend(buffer, request_size) < 0)
{
goto close_fd;
}
//discard the redundant data
if (buffer->length > request_size)
{
buffer->length = request_size;
}
if (buffer->length == request_size)
{
swReactorThread_dispatch(conn, buffer->str, buffer->length);
swHttpRequest_free(conn);
}
else
{
#ifdef SW_HTTP_100_CONTINUE
//Expect: 100-continue
if (swHttpRequest_has_expect_header(request))
{
swSendData _send;
_send.data = "HTTP/1.1 100 Continue\r\n\r\n";
_send.length = strlen(_send.data);
int send_times = 0;
direct_send:
n = swConnection_send(conn, _send.data, _send.length, 0);
if (n < _send.length)
{
_send.data += n;
_send.length -= n;
send_times++;
if (send_times < 10)
{
goto direct_send;
}
else
{
swWarn("send http header failed");
}
}
}
else
{
swTrace("PostWait: request->content_length=%d, buffer->length=%zd, request->header_length=%d\n",
request->content_length, buffer->length, request->header_length);
}
#endif
goto recv_data;
}
}
return SW_OK;
}
/**
* For Http Protocol
*/
static int swPort_onRead_http(swReactor *reactor, swListenPort *port, swEvent *event)
{
swConnection *conn = event->socket;
#ifdef SW_USE_OPENSSL
if (swPort_check_ssl_state(port, conn) < 0)
{
goto close_fd;
}
#endif
if (conn->websocket_status >= WEBSOCKET_STATUS_HANDSHAKE)
{
if (conn->object != NULL)
{
swHttpRequest_free(conn);
conn->websocket_status = WEBSOCKET_STATUS_ACTIVE;
}
return swPort_onRead_check_length(reactor, port, event);
}
int n = 0;
char *buf;
int buf_len;
swHttpRequest *request = NULL;
swProtocol *protocol = &port->protocol;
//new http request
if (conn->object == NULL)
{
request = sw_malloc(sizeof(swHttpRequest));
bzero(request, sizeof(swHttpRequest));
conn->object = request;
}
else
{
request = (swHttpRequest *) conn->object;
}
if (!request->buffer)
{
request->buffer = swString_new(SW_HTTP_HEADER_MAX_SIZE);
//alloc memory failed.
if (!request->buffer)
{
swReactorThread_onClose(reactor, event);
return SW_ERR;
}
}
swString *buffer = request->buffer;
recv_data:
buf = buffer->str + buffer->length;
buf_len = buffer->size - buffer->length;
n = swConnection_recv(conn, buf, buf_len, 0);
if (n < 0)
{
switch (swConnection_error(errno))
{
case SW_ERROR:
swSysError("recv from connection#%d failed.", event->fd);
return SW_OK;
case SW_CLOSE:
goto close_fd;
default:
return SW_OK;
}
}
else if (n == 0)
{
close_fd:
swHttpRequest_free(conn);
swReactorThread_onClose(reactor, event);
return SW_OK;
}
else
{
conn->last_time = SwooleGS->now;
buffer->length += n;
if (request->method == 0 && swHttpRequest_get_protocol(request) < 0)
{
if (request->buffer->length < SW_HTTP_HEADER_MAX_SIZE)
{
return SW_OK;
}
swWarn("get protocol failed.");
#ifdef SW_HTTP_BAD_REQUEST
if (swConnection_send(conn, SW_STRL(SW_HTTP_BAD_REQUEST) - 1, 0) < 0)
{
swSysError("send() failed.");
}
#endif
goto close_fd;
}
swTrace("request->method=%d", request->method);
//DELETE
if (request->method == HTTP_DELETE)
{
if (request->content_length == 0 && swHttpRequest_have_content_length(request) == SW_FALSE)
{
goto http_no_entity;
}
else
{
goto http_entity;
}
}
//GET HEAD OPTIONS
else if (request->method == HTTP_GET || request->method == HTTP_HEAD || request->method == HTTP_OPTIONS)
{
http_no_entity:
if (memcmp(buffer->str + buffer->length - 4, "\r\n\r\n", 4) == 0)
{
swReactorThread_dispatch(conn, buffer->str, buffer->length);
swHttpRequest_free(conn);
}
else if (buffer->size == buffer->length)
{
swWarn("http header is too long.");
goto close_fd;
}
//wait more data
else
{
goto recv_data;
}
}
//POST PUT HTTP_PATCH
else if (request->method == HTTP_POST || request->method == HTTP_PUT || request->method == HTTP_PATCH)
{
http_entity:
if (request->content_length == 0)
{
if (swHttpRequest_get_content_length(request) < 0)
{
if (buffer->size == buffer->length)
{
swWarn("http header is too long.");
goto close_fd;
}
else
{
goto recv_data;
}
}
else if (request->content_length > protocol->package_max_length)
{
swWarn("content-length more than the package_max_length[%d].", protocol->package_max_length);
goto close_fd;
}
}
uint32_t request_size = 0;
//http header is not the end
if (request->header_length == 0)
{
if (buffer->size == buffer->length)
{
swWarn("http header is too long.");
goto close_fd;
}
if (swHttpRequest_get_header_length(request) < 0)
{
goto recv_data;
}
request_size = request->content_length + request->header_length;
}
else
{
request_size = request->content_length + request->header_length;
}
if (request_size > buffer->size && swString_extend(buffer, request_size) < 0)
{
goto close_fd;
}
//discard the redundant data
if (buffer->length > request_size)
{
buffer->length = request_size;
}
if (buffer->length == request_size)
{
swReactorThread_dispatch(conn, buffer->str, buffer->length);
swHttpRequest_free(conn);
}
else
{
#ifdef SW_HTTP_100_CONTINUE
//Expect: 100-continue
if (swHttpRequest_has_expect_header(request))
{
swSendData _send;
_send.data = "HTTP/1.1 100 Continue\r\n\r\n";
_send.length = strlen(_send.data);
int send_times = 0;
direct_send:
n = swConnection_send(conn, _send.data, _send.length, 0);
if (n < _send.length)
{
_send.data += n;
_send.length -= n;
send_times++;
if (send_times < 10)
{
goto direct_send;
}
else
{
swWarn("send http header failed");
}
}
}
else
{
swTrace("PostWait: request->content_length=%d, buffer->length=%zd, request->header_length=%d\n",
request->content_length, buffer->length, request->header_length);
}
#endif
goto recv_data;
}
}
else
{
swWarn("method no support");
goto close_fd;
}
}
return SW_OK;
}
/**
* send to client or append to out_buffer
*/
int swReactorThread_send(swEventData *resp)
{
int buf_size, copy_n;
swServer *serv = SwooleG.serv;
swSendData send_data;
swEvent closeFd;
swBuffer_trunk *trunk;
swTask_sendfile *task;
swConnection *conn = swServer_get_connection(serv, resp->info.fd);
swReactor *reactor = &(serv->reactor_threads[conn->from_id].reactor);
//recv length=0, will close connection
if (resp->info.len == 0)
{
#ifdef SW_REACTOR_DIRECT_SEND
close_fd:
#endif
{
closeFd.fd = resp->info.fd;
closeFd.from_id = resp->info.from_id;
closeFd.type = SW_EVENT_CLOSE;
//printf("closeFd.fd=%d|from_id=%d\n", closeFd.fd, closeFd.from_id);
swReactorThread_onClose(reactor, &closeFd);
}
return SW_OK;
}
//sendfile to client
else if(resp->info.type == SW_EVENT_SENDFILE)
{
trunk = swConnection_get_out_buffer(conn, SW_TRUNK_SENDFILE);
if (trunk == NULL)
{
swWarn("get out_buffer trunk failed.");
return SW_ERR;
}
task = sw_malloc(sizeof(swTask_sendfile));
if (task == NULL)
{
swWarn("malloc for swTask_sendfile failed.");
//TODO: 回收这里的内存
return SW_ERR;
}
bzero(task, sizeof(swTask_sendfile));
int file_fd = open(resp->data, O_RDONLY);
if (file_fd < 0)
{
swWarn("open file[%s] failed. Error: %s[%d]", task->filename, strerror(errno), errno);
return SW_ERR;
}
struct stat file_stat;
if (fstat(file_fd, &file_stat) < 0)
{
swWarn("swoole_async_readfile: fstat failed. Error: %s[%d]", strerror(errno), errno);
return SW_ERR;
}
task->filesize = file_stat.st_size;
task->fd = file_fd;
trunk->data = (void *)task;
reactor->set(reactor, resp->info.fd, SW_EVENT_TCP | SW_EVENT_WRITE | SW_EVENT_READ);
}
//send data
else
{
send_data.data = resp->data;
send_data.info.len = resp->info.len;
send_data.info.from_id = resp->info.from_id;
send_data.info.fd = resp->info.fd;
#ifdef SW_REACTOR_DIRECT_SEND
if(!swBuffer_empty(conn->out_buffer))
{
trunk = swBuffer_get_trunk(conn->out_buffer);
#else
{
trunk = swConnection_get_out_buffer(conn, SW_TRUNK_DATA);
#endif
buf_size = conn->out_buffer->trunk_size - trunk->length;
#ifdef SW_REACTOR_DIRECT_SEND
append_out_buffer:
#else
//listen EPOLLOUT event
reactor->set(reactor, resp->info.fd, SW_EVENT_TCP | SW_EVENT_WRITE | SW_EVENT_READ);
#endif
do
{
copy_n = (buf_size >= send_data.info.len) ? send_data.info.len : buf_size;
memcpy(trunk->data, send_data.data, copy_n);
send_data.data += copy_n;
send_data.info.len -= copy_n;
trunk->length += copy_n;
buf_size += copy_n;
//trunk is full, create new trunk
if (trunk->length == conn->out_buffer->trunk_size)
{
//trunk no enough space, creating a new trunk
trunk = swBuffer_new_trunk(conn->out_buffer, SW_TRUNK_DATA);
if (trunk == NULL)
{
swWarn("append to out_buffer failed.");
return SW_ERR;
}
buf_size = conn->out_buffer->trunk_size;
}
} while(send_data.info.len > 0);
}
#ifdef SW_REACTOR_DIRECT_SEND
else
{
//try send
int ret = swWrite(send_data.info.fd, send_data.data, send_data.info.len);
if (ret < 0)
{
//连接已被关闭
if (errno == ECONNRESET || errno == EBADF)
{
goto close_fd;
}
swWarn("factory->onFinish failed.fd=%d|from_id=%d. Error: %s[%d]", resp->info.fd, resp->info.from_id, strerror(errno), errno);
}
//Did not finish, add to writable event callback
else if(ret < resp->info.len)
{
trunk = swConnection_get_out_buffer(conn, SW_TRUNK_DATA);
send_data.data += ret;
send_data.info.len -= ret;
buf_size = conn->out_buffer->trunk_size;
goto append_out_buffer;
}
//printf("[writer]pop.fd=%d|from_id=%d|data=%s\n", resp->info.fd, resp->info.from_id, resp->data);
}
#endif
}
