swString* swoole_file_get_contents(char *filename)
{
long filesize = swoole_file_size(filename);
if (filesize < 0)
{
return NULL;
}
else if (filesize == 0)
{
swoole_error_log(SW_LOG_TRACE, SW_ERROR_FILE_EMPTY, "file[%s] is empty.", filename);
return NULL;
}
else if (filesize > SW_MAX_FILE_CONTENT)
{
swoole_error_log(SW_LOG_WARNING, SW_ERROR_FILE_TOO_LARGE, "file[%s] is too large.", filename);
return NULL;
}
int fd = open(filename, O_RDONLY);
if (fd < 0)
{
swWarn("open(%s) failed. Error: %s[%d]", filename, strerror(errno), errno);
return NULL;
}
swString *content = swString_new(filesize);
if (!content)
{
close(fd);
return NULL;
}
int readn = 0;
int n;
while(readn < filesize)
{
n = pread(fd, content->str + readn, filesize - readn, readn);
if (n < 0)
{
if (errno == EINTR)
{
continue;
}
else
{
swSysError("pread(%d, %ld, %d) failed.", fd, filesize - readn, readn);
swString_free(content);
close(fd);
return NULL;
}
}
readn += n;
}
close(fd);
content->length = readn;
return content;
}
void swoole_redirect_stdout(int new_fd)
{
if (dup2(new_fd, STDOUT_FILENO) < 0)
{
swoole_error_log(SW_LOG_ERROR, SW_ERROR_SYSTEM_CALL_FAIL, "dup2(STDOUT_FILENO) failed. Error: %s[%d]", strerror(errno), errno);
}
if (dup2(new_fd, STDERR_FILENO) < 0)
{
swoole_error_log(SW_LOG_ERROR, SW_ERROR_SYSTEM_CALL_FAIL, "dup2(STDERR_FILENO) failed. Error: %s[%d]", strerror(errno), errno);
}
}
int swSocket_create_server(int type, char *address, int port, int backlog)
{
#if 0
int type;
char host[32];
int port = 0;
if (strncasecmp(address, "unix:/", 6) == 0)
{
address += 5;
type = SW_SOCK_UNIX_STREAM;
}
else
{
char *port_str = strchr(address, ':');
if (!port_str)
{
swoole_error_log(SW_LOG_ERROR, SW_ERROR_INVALID_PARAMS, "invalid address[%s]", address);
return SW_ERR;
}
type = SW_SOCK_TCP6;
memcpy(host, address, port_str - address);
host[port_str - address] = 0;
port = atoi(port_str + 1);
address = host;
}
#endif
int fd = swSocket_create(type);
if (fd < 0)
{
swoole_error_log(SW_LOG_ERROR, SW_ERROR_SYSTEM_CALL_FAIL, "socket() failed. Error: %s[%d]", strerror(errno), errno);
return SW_ERR;
}
if (swSocket_bind(fd, type, address, &port) < 0)
{
close(fd);
return SW_ERR;
}
if (listen(fd, backlog) < 0)
{
swoole_error_log(SW_LOG_ERROR, SW_ERROR_SYSTEM_CALL_FAIL, "listen(%s:%d, %d) failed. Error: %s[%d]", address, port, backlog, strerror(errno), errno);
close(fd);
return SW_ERR;
}
return fd;
}
int swoole_file_put_contents(char *filename, char *content, size_t length)
{
if (length <= 0)
{
swoole_error_log(SW_LOG_TRACE, SW_ERROR_FILE_EMPTY, "content is empty.");
return SW_ERR;
}
if (length > SW_MAX_FILE_CONTENT)
{
swoole_error_log(SW_LOG_WARNING, SW_ERROR_FILE_TOO_LARGE, "content is too large.");
return SW_ERR;
}
int fd = open(filename, O_WRONLY | O_TRUNC | O_CREAT, 0666);
if (fd < 0)
{
swSysError("open(%s) failed.", filename);
return SW_ERR;
}
int n, chunk_size, written = 0;
while(written < length)
{
chunk_size = length - written;
if (chunk_size > SW_BUFFER_SIZE_BIG)
{
chunk_size = SW_BUFFER_SIZE_BIG;
}
n = write(fd, content + written, chunk_size);
if (n < 0)
{
if (errno == EINTR)
{
continue;
}
else
{
swSysError("write(%d, %d) failed.", fd, chunk_size);
close(fd);
return -1;
}
}
written += n;
}
close(fd);
return SW_OK;
}
static int swFactoryProcess_end(swFactory *factory, int fd)
{
swServer *serv = factory->ptr;
swSendData _send;
swDataHead info;
bzero(&_send, sizeof(_send));
_send.info.fd = fd;
_send.info.len = 0;
_send.info.type = SW_EVENT_CLOSE;
swConnection *conn = swWorker_get_connection(serv, fd);
if (conn == NULL || conn->active == 0)
{
SwooleG.error = SW_ERROR_SESSION_NOT_EXIST;
return SW_ERR;
}
else if (conn->close_force)
{
goto do_close;
}
else if (conn->closing)
{
swoole_error_log(SW_LOG_NOTICE, SW_ERROR_SESSION_CLOSING, "The connection[%d] is closing.", fd);
return SW_ERR;
}
else if (conn->closed)
{
return SW_ERR;
}
else
{
do_close:
conn->closing = 1;
if (serv->onClose != NULL)
{
info.fd = fd;
if (conn->close_actively)
{
info.from_id = -1;
}
else
{
info.from_id = conn->from_id;
}
info.from_fd = conn->from_fd;
serv->onClose(serv, &info);
}
conn->closing = 0;
conn->closed = 1;
conn->close_errno = 0;
return factory->finish(factory, &_send);
}
}
static sw_inline int swWorker_discard_data(swServer *serv, swEventData *task)
{
int fd = task->info.fd;
//check connection
swConnection *conn = swServer_connection_verify(serv, task->info.fd);
if (conn == NULL)
{
if (serv->disable_notify && !serv->discard_timeout_request)
{
return SW_FALSE;
}
goto discard_data;
}
else
{
if (conn->closed)
{
goto discard_data;
}
else
{
return SW_FALSE;
}
}
discard_data:
#ifdef SW_USE_RINGBUFFER
if (task->info.type == SW_EVENT_PACKAGE)
{
swPackage package;
memcpy(&package, task->data, sizeof(package));
swReactorThread *thread = swServer_get_thread(SwooleG.serv, task->info.from_id);
thread->buffer_input->free(thread->buffer_input, package.data);
swoole_error_log(SW_LOG_WARNING, SW_ERROR_SESSION_DISCARD_TIMEOUT_DATA, "[1]received the wrong data[%d bytes] from socket#%d", package.length, fd);
}
else
#endif
{
swoole_error_log(SW_LOG_WARNING, SW_ERROR_SESSION_DISCARD_TIMEOUT_DATA, "[1]received the wrong data[%d bytes] from socket#%d", task->info.len, fd);
}
return SW_TRUE;
}
swModule* swModule_load(char *so_file)
{
int (*init_func)(swModule*);
void *handle = dlopen(so_file, RTLD_LAZY);
if (!handle)
{
swWarn("dlopen() failed. Error: %s", dlerror());
return NULL;
}
//malloc
swModule *module = (swModule *) sw_malloc(sizeof(swModule));
if (module == NULL)
{
swoole_error_log(SW_LOG_ERROR, SW_ERROR_MALLOC_FAIL, "malloc failed.");
return NULL;
}
//get init function
init_func = (int (*)(swModule*)) dlsym(handle, SW_MODULE_INIT_FUNC);
char *error = dlerror();
if (error != NULL)
{
swWarn("dlsym() failed. Error: %s", error);
sw_free(module);
return NULL;
}
module->file = strdup(so_file);
//create function hashmap
module->functions = swHashMap_new(64, NULL);
if (module->functions == NULL)
{
sw_free(module);
return NULL;
}
//init module
if ((*init_func)(module) < 0)
{
sw_free(module);
return NULL;
}
return module;
}
void swoole_websocket_onOpen(http_context *ctx)
{
#if PHP_MAJOR_VERSION < 7
TSRMLS_FETCH_FROM_CTX(sw_thread_ctx ? sw_thread_ctx : NULL);
#endif
int fd = ctx->fd;
swConnection *conn = swWorker_get_connection(SwooleG.serv, fd);
if (!conn)
{
swoole_error_log(SW_LOG_NOTICE, SW_ERROR_SESSION_CLOSED, "session[%d] is closed.", fd);
return;
}
conn->websocket_status = WEBSOCKET_STATUS_ACTIVE;
zval *zcallback = php_swoole_server_get_callback(SwooleG.serv, conn->from_fd, SW_SERVER_CB_onOpen);
if (zcallback)
{
zval **args[2];
swServer *serv = SwooleG.serv;
zval *zserv = (zval *) serv->ptr2;
zval *zrequest_object = ctx->request.zobject;
zval *retval = NULL;
args[0] = &zserv;
args[1] = &zrequest_object;
if (sw_call_user_function_ex(EG(function_table), NULL, zcallback, &retval, 2, args, 0, NULL TSRMLS_CC) == FAILURE)
{
php_error_docref(NULL TSRMLS_CC, E_WARNING, "onOpen handler error");
}
if (EG(exception))
{
zend_exception_error(EG(exception), E_ERROR TSRMLS_CC);
}
if (retval)
{
sw_zval_ptr_dtor(&retval);
}
}
}
int swSSL_verify(swConnection *conn, int allow_self_signed)
{
int err = SSL_get_verify_result(conn->ssl);
switch (err)
{
case X509_V_OK:
return SW_OK;
case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
if (allow_self_signed)
{
return SW_OK;
}
else
{
return SW_ERR;
}
default:
swoole_error_log(SW_LOG_NOTICE, SW_ERROR_SSL_VEFIRY_FAILED, "Could not verify peer: code:%d %s", err, X509_verify_cert_error_string(err));
return SW_ERR;
}
return SW_ERR;
}
void swoole_websocket_onOpen(http_context *ctx)
{
#if PHP_MAJOR_VERSION < 7
TSRMLS_FETCH_FROM_CTX(sw_thread_ctx ? sw_thread_ctx : NULL);
#endif
int fd = ctx->fd;
swConnection *conn = swWorker_get_connection(SwooleG.serv, fd);
if (!conn)
{
swoole_error_log(SW_LOG_NOTICE, SW_ERROR_SESSION_CLOSED, "session[%d] is closed.", fd);
return;
}
conn->websocket_status = WEBSOCKET_STATUS_ACTIVE;
zend_fcall_info_cache *cache = php_swoole_server_get_cache(SwooleG.serv, conn->from_fd, SW_SERVER_CB_onOpen);
if (cache)
{
swServer *serv = SwooleG.serv;
zval *zserv = (zval *) serv->ptr2;
zval *zrequest_object = ctx->request.zobject;
zval *retval = NULL;
#ifndef SW_COROUTINE
zval **args[2];
args[0] = &zserv;
args[1] = &zrequest_object;
#else
zval *args[2];
args[0] = zserv;
args[1] = zrequest_object;
#endif
#ifndef SW_COROUTINE
zval *zcallback = php_swoole_server_get_callback(SwooleG.serv, conn->from_fd, SW_SERVER_CB_onOpen);
if (sw_call_user_function_fast(zcallback, cache, &retval, 2, args TSRMLS_CC) == FAILURE)
{
swoole_php_error(E_WARNING, "onOpen handler error");
}
#else
int ret = coro_create(cache, args, 2, &retval, NULL, NULL);
if (ret != 0)
{
if (ret == CORO_LIMIT)
{
SwooleG.serv->factory.end(&SwooleG.serv->factory, fd);
}
return;
}
#endif
if (EG(exception))
{
zend_exception_error(EG(exception), E_ERROR TSRMLS_CC);
}
if (retval)
{
sw_zval_ptr_dtor(&retval);
}
}
}
/**
* 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;
}
int swSocket_bind(int sock, int type, char *host, int *port)
{
int ret;
struct sockaddr_in addr_in4;
struct sockaddr_in6 addr_in6;
struct sockaddr_un addr_un;
socklen_t len;
//SO_REUSEADDR option
int option = 1;
if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &option, sizeof(int)) < 0)
{
swoole_error_log(SW_LOG_WARNING, SW_ERROR_SYSTEM_CALL_FAIL, "setsockopt(%d, SO_REUSEADDR) failed.", sock);
}
//reuse port
#ifdef HAVE_REUSEPORT
if (SwooleG.reuse_port)
{
if (setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, &option, sizeof(int)) < 0)
{
swSysError("setsockopt(SO_REUSEPORT) failed.");
SwooleG.reuse_port = 0;
}
}
#endif
//unix socket
if (type == SW_SOCK_UNIX_DGRAM || type == SW_SOCK_UNIX_STREAM)
{
bzero(&addr_un, sizeof(addr_un));
unlink(host);
addr_un.sun_family = AF_UNIX;
strncpy(addr_un.sun_path, host, sizeof(addr_un.sun_path) - 1);
ret = bind(sock, (struct sockaddr*) &addr_un, sizeof(addr_un));
}
//IPv6
else if (type > SW_SOCK_UDP)
{
bzero(&addr_in6, sizeof(addr_in6));
inet_pton(AF_INET6, host, &(addr_in6.sin6_addr));
addr_in6.sin6_port = htons(*port);
addr_in6.sin6_family = AF_INET6;
ret = bind(sock, (struct sockaddr *) &addr_in6, sizeof(addr_in6));
if (ret == 0 && *port == 0)
{
len = sizeof(addr_in6);
if (getsockname(sock, (struct sockaddr *) &addr_in6, &len) != -1)
{
*port = ntohs(addr_in6.sin6_port);
}
}
}
//IPv4
else
{
bzero(&addr_in4, sizeof(addr_in4));
inet_pton(AF_INET, host, &(addr_in4.sin_addr));
addr_in4.sin_port = htons(*port);
addr_in4.sin_family = AF_INET;
ret = bind(sock, (struct sockaddr *) &addr_in4, sizeof(addr_in4));
if (ret == 0 && *port == 0)
{
len = sizeof(addr_in4);
if (getsockname(sock, (struct sockaddr *) &addr_in4, &len) != -1)
{
*port = ntohs(addr_in4.sin_port);
}
}
}
//bind failed
if (ret < 0)
{
swoole_error_log(SW_LOG_WARNING, SW_ERROR_SYSTEM_CALL_FAIL, "bind(%s:%d) failed. Error: %s [%d]", host, *port, strerror(errno), errno);
return SW_ERR;
}
return ret;
}
/**
* worker: send to client
*/
static int swFactoryProcess_finish(swFactory *factory, swSendData *resp)
{
int ret, sendn;
swServer *serv = factory->ptr;
int session_id = resp->info.fd;
swConnection *conn;
if (resp->info.type != SW_EVENT_CLOSE)
{
conn = swServer_connection_verify(serv, session_id);
}
else
{
conn = swServer_connection_verify_no_ssl(serv, session_id);
}
if (!conn)
{
swoole_error_log(SW_LOG_NOTICE, SW_ERROR_SESSION_NOT_EXIST, "connection[fd=%d] does not exists.", session_id);
return SW_ERR;
}
else if ((conn->closed || conn->removed) && resp->info.type != SW_EVENT_CLOSE)
{
int _len = resp->length > 0 ? resp->length : resp->info.len;
swoole_error_log(SW_LOG_NOTICE, SW_ERROR_SESSION_CLOSED, "send %d byte failed, because connection[fd=%d] is closed.", _len, session_id);
return SW_ERR;
}
else if (conn->overflow)
{
swoole_error_log(SW_LOG_WARNING, SW_ERROR_OUTPUT_BUFFER_OVERFLOW, "send failed, connection[fd=%d] output buffer has been overflowed.", session_id);
return SW_ERR;
}
swEventData ev_data;
ev_data.info.fd = session_id;
ev_data.info.type = resp->info.type;
swWorker *worker = swServer_get_worker(serv, SwooleWG.id);
/**
* Big response, use shared memory
*/
if (resp->length > 0)
{
if (worker == NULL || worker->send_shm == NULL)
{
goto pack_data;
}
//worker process
if (SwooleG.main_reactor)
{
int _pipe_fd = swWorker_get_send_pipe(serv, session_id, conn->from_id);
swConnection *_pipe_socket = swReactor_get(SwooleG.main_reactor, _pipe_fd);
//cannot use send_shm
if (!swBuffer_empty(_pipe_socket->out_buffer))
{
pack_data:
if (swTaskWorker_large_pack(&ev_data, resp->data, resp->length) < 0)
{
return SW_ERR;
}
ev_data.info.from_fd = SW_RESPONSE_TMPFILE;
goto send_to_reactor_thread;
}
}
swPackage_response response;
response.length = resp->length;
response.worker_id = SwooleWG.id;
ev_data.info.from_fd = SW_RESPONSE_SHM;
ev_data.info.len = sizeof(response);
memcpy(ev_data.data, &response, sizeof(response));
swTrace("[Worker] big response, length=%d|worker_id=%d", response.length, response.worker_id);
worker->lock.lock(&worker->lock);
memcpy(worker->send_shm, resp->data, resp->length);
}
else
{
//copy data
memcpy(ev_data.data, resp->data, resp->info.len);
ev_data.info.len = resp->info.len;
ev_data.info.from_fd = SW_RESPONSE_SMALL;
}
send_to_reactor_thread: ev_data.info.from_id = conn->from_id;
sendn = ev_data.info.len + sizeof(resp->info);
swTrace("[Worker] send: sendn=%d|type=%d|content=%s", sendn, resp->info.type, resp->data);
ret = swWorker_send2reactor(&ev_data, sendn, session_id);
if (ret < 0)
{
swWarn("sendto to reactor failed. Error: %s [%d]", strerror(errno), errno);
}
return ret;
}
int swSocks5_connect(swClient *cli, char *recv_data, int length)
{
swSocks5 *ctx = cli->socks5_proxy;
char *buf = ctx->buf;
if (ctx->state == SW_SOCKS5_STATE_HANDSHAKE)
{
uchar version = recv_data[0];
uchar method = recv_data[1];
if (version != SW_SOCKS5_VERSION_CODE)
{
swoole_error_log(SW_LOG_NOTICE, SW_ERROR_SOCKS5_UNSUPPORT_VERSION, "SOCKS version is not supported.");
return SW_ERR;
}
if (method != ctx->method)
{
swoole_error_log(SW_LOG_NOTICE, SW_ERROR_SOCKS5_UNSUPPORT_METHOD, "SOCKS authentication method not supported.");
return SW_ERR;
}
//authenticate request
if (method == SW_SOCKS5_METHOD_AUTH)
{
buf[0] = 0x01;
buf[1] = ctx->l_username;
buf += 2;
memcpy(buf, ctx->username, ctx->l_username);
buf += ctx->l_username;
buf[0] = ctx->l_password;
memcpy(buf + 1, ctx->password, ctx->l_password);
ctx->state = SW_SOCKS5_STATE_AUTH;
return cli->send(cli, ctx->buf, ctx->l_username + ctx->l_password + 3, 0);
}
//send connect request
else
{
send_connect_request:
buf[0] = SW_SOCKS5_VERSION_CODE;
buf[1] = 0x01;
buf[2] = 0x00;
ctx->state = SW_SOCKS5_STATE_CONNECT;
if (ctx->dns_tunnel)
{
buf[3] = 0x03;
buf[4] = ctx->l_target_host;
buf += 5;
memcpy(buf, ctx->target_host, ctx->l_target_host);
buf += ctx->l_target_host;
*(uint16_t *) buf = htons(ctx->target_port);
return cli->send(cli, ctx->buf, ctx->l_target_host + 7, 0);
}
else
{
buf[3] = 0x01;
buf += 4;
*(uint32_t *) buf = htons(ctx->l_target_host);
buf += 4;
*(uint16_t *) buf = htons(ctx->target_port);
return cli->send(cli, ctx->buf, ctx->l_target_host + 7, 0);
}
}
}
else if (ctx->state == SW_SOCKS5_STATE_AUTH)
{
uchar version = recv_data[0];
uchar status = recv_data[1];
if (version != 0x01)
{
swoole_error_log(SW_LOG_NOTICE, SW_ERROR_SOCKS5_UNSUPPORT_VERSION, "SOCKS version is not supported.");
return SW_ERR;
}
if (status != 0)
{
swoole_error_log(SW_LOG_NOTICE, SW_ERROR_SOCKS5_AUTH_FAILED, "SOCKS username/password authentication failed.");
return SW_ERR;
}
goto send_connect_request;
}
else if (ctx->state == SW_SOCKS5_STATE_CONNECT)
{
uchar version = recv_data[0];
if (version != SW_SOCKS5_VERSION_CODE)
{
swoole_error_log(SW_LOG_NOTICE, SW_ERROR_SOCKS5_UNSUPPORT_VERSION, "SOCKS version is not supported.");
return SW_ERR;
}
uchar result = recv_data[1];
#if 0
uchar reg = recv_data[2];
uchar type = recv_data[3];
uint32_t ip = *(uint32_t *) (recv_data + 4);
uint16_t port = *(uint16_t *) (recv_data + 8);
#endif
if (result == 0)
{
ctx->state = SW_SOCKS5_STATE_READY;
}
else
{
swoole_error_log(SW_LOG_NOTICE, SW_ERROR_SOCKS5_SERVER_ERROR, "Socks5 server error, reason :%s.", swSocks5_strerror(result));
}
return result;
}
return SW_OK;
}
static int swClient_onStreamRead(swReactor *reactor, swEvent *event)
{
int n;
swClient *cli = event->socket->object;
char *buf = cli->buffer->str + cli->buffer->length;
long buf_size = cli->buffer->size - cli->buffer->length;
if (cli->http_proxy && cli->http_proxy->state != SW_HTTP_PROXY_STATE_READY)
{
#ifdef SW_USE_OPENSSL
if (cli->open_ssl)
{
int n = swConnection_recv(event->socket, buf, buf_size, 0);
if (n <= 0)
{
goto __close;
}
cli->buffer->length += n;
if (cli->buffer->length < sizeof(SW_HTTPS_PROXY_HANDSHAKE_RESPONSE) - 1)
{
return SW_OK;
}
if (swClient_https_proxy_handshake(cli) < 0)
{
swoole_error_log(SW_LOG_NOTICE, SW_ERROR_HTTP_PROXY_HANDSHAKE_ERROR, "failed to handshake with http proxy.");
goto connect_fail;
}
else
{
cli->http_proxy->state = SW_HTTP_PROXY_STATE_READY;
swString_clear(cli->buffer);
}
if (swClient_enable_ssl_encrypt(cli) < 0)
{
goto connect_fail;
}
else
{
if (swClient_ssl_handshake(cli) < 0)
{
goto connect_fail;
}
else
{
cli->socket->ssl_state = SW_SSL_STATE_WAIT_STREAM;
}
return SwooleG.main_reactor->set(SwooleG.main_reactor, event->fd, SW_FD_STREAM_CLIENT | SW_EVENT_WRITE);
}
if (cli->onConnect)
{
execute_onConnect(cli);
}
return SW_OK;
}
#endif
}
if (cli->socks5_proxy && cli->socks5_proxy->state != SW_SOCKS5_STATE_READY)
{
int n = swConnection_recv(event->socket, buf, buf_size, 0);
if (n <= 0)
{
goto __close;
}
if (swSocks5_connect(cli, buf, buf_size) < 0)
{
goto __close;
}
if (cli->socks5_proxy->state != SW_SOCKS5_STATE_READY)
{
return SW_OK;
}
#ifdef SW_USE_OPENSSL
if (cli->open_ssl)
{
if (swClient_enable_ssl_encrypt(cli) < 0)
{
connect_fail:
cli->socket->active = 0;
cli->close(cli);
if (cli->onError)
{
cli->onError(cli);
}
}
else
{
if (swClient_ssl_handshake(cli) < 0)
{
goto connect_fail;
}
else
{
cli->socket->ssl_state = SW_SSL_STATE_WAIT_STREAM;
}
return SwooleG.main_reactor->set(SwooleG.main_reactor, event->fd, SW_FD_STREAM_CLIENT | SW_EVENT_WRITE);
}
}
else
#endif
{
if (cli->onConnect)
{
execute_onConnect(cli);
}
}
return SW_OK;
}
#ifdef SW_USE_OPENSSL
if (cli->open_ssl && cli->socket->ssl_state == SW_SSL_STATE_WAIT_STREAM)
{
if (swClient_ssl_handshake(cli) < 0)
{
return cli->close(cli);
}
if (cli->socket->ssl_state != SW_SSL_STATE_READY)
{
return SW_OK;
}
//ssl handshake sucess
else if (cli->onConnect)
{
execute_onConnect(cli);
}
}
#endif
/**
* redirect stream data to other socket
*/
if (cli->redirect)
{
int ret = 0;
n = swConnection_recv(event->socket, buf, buf_size, 0);
if (n < 0)
{
goto __error;
}
else if (n == 0)
{
goto __close;
}
if (cli->_redirect_to_socket)
{
ret = SwooleG.main_reactor->write(SwooleG.main_reactor, cli->_redirect_to_socket, buf, n);
}
else if (cli->_redirect_to_session)
{
if (SwooleG.serv->send(SwooleG.serv, cli->_redirect_to_session, buf, n) < 0)
{
if (SwooleG.error >= SW_ERROR_SESSION_CLOSED_BY_SERVER || SwooleG.error >= SW_ERROR_SESSION_INVALID_ID)
{
goto __close;
}
}
else
{
return SW_OK;
}
}
else
{
ret = swSocket_write_blocking(cli->_redirect_to_file, buf, n);
}
if (ret < 0)
{
goto __error;
}
return SW_OK;
}
if (cli->open_eof_check || cli->open_length_check)
{
swConnection *conn = cli->socket;
swProtocol *protocol = &cli->protocol;
if (cli->open_eof_check)
{
n = swProtocol_recv_check_eof(protocol, conn, cli->buffer);
}
else
{
n = swProtocol_recv_check_length(protocol, conn, cli->buffer);
}
if (n < 0)
{
return cli->close(cli);
}
else
{
return SW_OK;
}
}
#ifdef SW_CLIENT_RECV_AGAIN
recv_again:
#endif
n = swConnection_recv(event->socket, buf, buf_size, 0);
if (n < 0)
{
__error:
switch (swConnection_error(errno))
{
case SW_ERROR:
swSysError("Read from socket[%d] failed.", event->fd);
return SW_OK;
case SW_CLOSE:
goto __close;
case SW_WAIT:
return SW_OK;
default:
return SW_OK;
}
}
else if (n == 0)
{
__close:
return cli->close(cli);
}
else
{
cli->onReceive(cli, buf, n);
#ifdef SW_CLIENT_RECV_AGAIN
if (n == buf_size)
{
goto recv_again;
}
#endif
return SW_OK;
}
return SW_OK;
}
