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;
}
/**
* 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;
}