lvfulong
751 lines
21 KiB
C++
751 lines
21 KiB
C++
/****************************************************************************
|
||
Copyright (c) 2014 kuo.wang
|
||
|
||
"[WebSocket module] is based in part on the work of the libwebsockets project
|
||
(http://libwebsockets.org)"
|
||
|
||
****************************************************************************/
|
||
|
||
#include "WebSocket.h"
|
||
#include "Uri.h"
|
||
#include <thread>
|
||
#include <mutex>
|
||
#include <queue>
|
||
#include <signal.h>
|
||
#include <errno.h>
|
||
#include "../JCConch.h"
|
||
#include <libwebsockets.h>
|
||
#include <thread>
|
||
#include <stdlib.h>
|
||
#include <downloadCache/JCFileSource.h>
|
||
#ifdef ANDROID
|
||
#include <downloadCache/JCAndroidFileSource.h>
|
||
#elif __APPLE_
|
||
#include <downloadCache/JCIosFileSource.h>
|
||
#endif
|
||
#include "util/Log.h"
|
||
#ifdef WIN32
|
||
#include <filesystem>
|
||
namespace fs = std::experimental::filesystem::v1;
|
||
#else
|
||
#include "fileSystem/JCFileSystem.h"
|
||
#endif
|
||
extern std::string gRedistPath;
|
||
extern std::string gResourcePath;
|
||
namespace laya{
|
||
|
||
std::string WebSocket::s_strProxy;
|
||
class WsMessage
|
||
{
|
||
public:
|
||
WsMessage() : what(0), obj(NULL){}
|
||
unsigned int what; // message type
|
||
void* obj;
|
||
};
|
||
|
||
/**
|
||
* @brief Websocket thread helper, it's used for sending message between JS thread and websocket thread.
|
||
*/
|
||
class WsThreadHelper
|
||
{
|
||
public:
|
||
WsThreadHelper();
|
||
~WsThreadHelper();
|
||
|
||
// Creates a new thread
|
||
bool createThread(const WebSocket& ws);
|
||
// Quits sub-thread (websocket thread).
|
||
void quitSubThread();
|
||
|
||
// Sends message to UI thread. It's needed to be invoked in sub-thread.
|
||
void sendMessageToJSThread(WsMessage *msg);
|
||
|
||
// Sends message to sub-thread(websocket thread). It's needs to be invoked in JS thread.
|
||
void sendMessageToSubThread(WsMessage *msg);
|
||
|
||
// Waits the sub-thread (websocket thread) to exit,
|
||
void joinSubThread();
|
||
|
||
protected:
|
||
void wsThreadEntryFunc();
|
||
|
||
private:
|
||
std::list<WsMessage*>* m_subThreadWsMessageQueue;
|
||
//std::mutex m_subThreadWsMessageQueueMutex;
|
||
//std::thread* _subThreadInstance;
|
||
|
||
WebSocket* m_pWebSocket;
|
||
bool m_needQuit;
|
||
std::thread *m_subThreadInstance;
|
||
std::mutex *m_subThreadWsMessageQueueMutex;
|
||
std::mutex *m_JSWsMessageQueueMutex;
|
||
|
||
friend class WebSocket;
|
||
};
|
||
|
||
// Wrapper for converting websocket callback from static function to member function of WebSocket class.
|
||
class WebSocketCallbackWrapper {
|
||
public:
|
||
|
||
static int onSocketCallback(
|
||
struct lws *wsi,
|
||
lws_callback_reasons reason,
|
||
void *user, void *in, size_t len)
|
||
{
|
||
if (reason == LWS_CALLBACK_GET_THREAD_ID) {
|
||
//这个也不知道有什么用，就随便返回一个值吧
|
||
auto id = std::this_thread::get_id();
|
||
std::hash<std::thread::id> sh;
|
||
return sh(id);
|
||
}
|
||
// Gets the user data from context. We know that it's a 'WebSocket' instance.
|
||
struct lws_context* pCtx = lws_get_context(wsi);
|
||
WebSocket* wsInstance = (WebSocket*)(lws_context_user(pCtx));//lws_context_user(ctx);
|
||
if (wsInstance)
|
||
{
|
||
return wsInstance->onSocketCallback(wsi, reason, user, in, len);
|
||
}
|
||
return 0;
|
||
}
|
||
};
|
||
|
||
// Implementation of WsThreadHelper
|
||
WsThreadHelper::WsThreadHelper()
|
||
: m_subThreadInstance(nullptr)
|
||
,m_subThreadWsMessageQueueMutex(NULL)
|
||
,m_pWebSocket(NULL)
|
||
,m_needQuit(false)
|
||
{
|
||
m_subThreadWsMessageQueue = new std::list<WsMessage*>();
|
||
}
|
||
|
||
WsThreadHelper::~WsThreadHelper()
|
||
{
|
||
joinSubThread();
|
||
LAYA_SAFE_DELETE(m_subThreadInstance);
|
||
LAYA_SAFE_DELETE(m_subThreadWsMessageQueueMutex);
|
||
LAYA_SAFE_DELETE(m_JSWsMessageQueueMutex);
|
||
delete m_subThreadWsMessageQueue;
|
||
}
|
||
|
||
bool WsThreadHelper::createThread(const WebSocket& ws)
|
||
{
|
||
m_pWebSocket = const_cast<WebSocket*>(&ws);
|
||
|
||
// Creates websocket thread
|
||
m_subThreadWsMessageQueueMutex = new std::mutex();
|
||
m_JSWsMessageQueueMutex = new std::mutex();
|
||
m_subThreadInstance = new std::thread(&WsThreadHelper::wsThreadEntryFunc,this);
|
||
return true;
|
||
}
|
||
|
||
void WsThreadHelper::quitSubThread()
|
||
{
|
||
m_needQuit = true;
|
||
}
|
||
|
||
void WsThreadHelper::wsThreadEntryFunc()
|
||
{
|
||
m_pWebSocket->onSubThreadStarted();
|
||
//先等个500毫秒再调用 libwebsocket_service
|
||
//否则再第二次调用connect的时候会出错（可能是win64和ws2的异步连接的问题？）
|
||
#ifdef WIN32
|
||
std::this_thread::sleep_for(std::chrono::milliseconds(500));
|
||
#endif
|
||
while (!m_needQuit)
|
||
{
|
||
if (m_pWebSocket->onSubThreadLoop())
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
|
||
m_pWebSocket->onSubThreadEnded();
|
||
}
|
||
|
||
void WsThreadHelper::sendMessageToJSThread(WsMessage *msg)
|
||
{
|
||
std::lock_guard<std::mutex> lock(*m_JSWsMessageQueueMutex);
|
||
m_pWebSocket->onJSThreadReceiveMessage(msg);
|
||
}
|
||
|
||
void WsThreadHelper::sendMessageToSubThread(WsMessage *msg)
|
||
{
|
||
std::lock_guard<std::mutex> lock(*m_subThreadWsMessageQueueMutex);
|
||
m_subThreadWsMessageQueue->push_back(msg);
|
||
}
|
||
|
||
void WsThreadHelper::joinSubThread()
|
||
{
|
||
if(m_subThreadInstance->joinable())
|
||
{
|
||
m_subThreadInstance->join();
|
||
}
|
||
}
|
||
|
||
enum WS_MSG {
|
||
WS_MSG_TO_SUBTRHEAD_SENDING_STRING = 0,
|
||
WS_MSG_TO_SUBTRHEAD_SENDING_BINARY,
|
||
WS_MSG_TO_JS_THREAD_OPEN,
|
||
WS_MSG_TO_JS_THREAD_MESSAGE,
|
||
WS_MSG_TO_JS_THREAD_ERROR,
|
||
WS_MSG_TO_JS_THREAD_CLOSE
|
||
};
|
||
|
||
WebSocket::WebSocket()
|
||
: m_readyState(State::CONNECTING)
|
||
, m_port(80)
|
||
, m_wsHelper(nullptr)
|
||
, m_wsInstance(nullptr)
|
||
, m_wsContext(nullptr)
|
||
, m_delegate(nullptr)
|
||
, m_SSLConnection(0)
|
||
, m_wsProtocols(nullptr)
|
||
, m_bWantClose(false)
|
||
{
|
||
}
|
||
|
||
WebSocket::~WebSocket()
|
||
{
|
||
close();
|
||
LAYA_SAFE_DELETE(m_wsHelper);
|
||
|
||
for (int i = 0; m_wsProtocols[i].callback != nullptr; ++i)
|
||
{
|
||
LAYA_SAFE_DELETE_ARRAY(m_wsProtocols[i].name);
|
||
}
|
||
LAYA_SAFE_DELETE_ARRAY(m_wsProtocols);
|
||
}
|
||
|
||
bool WebSocket::init(const Delegate& delegate,
|
||
const std::string& url,
|
||
const std::vector<std::string>* protocols/* = NULL*/)
|
||
{
|
||
bool ret = false;
|
||
|
||
m_delegate = const_cast<Delegate*>(&delegate);
|
||
|
||
Uri uri = Uri::parse(url);
|
||
|
||
|
||
int port = static_cast<int>(uri.getPort());
|
||
if (port == 0)
|
||
port = uri.isSecure() ? 443 : 80;
|
||
|
||
std::string path = uri.getPathEtc();
|
||
if (path.empty())
|
||
path = "/";
|
||
|
||
|
||
m_host = uri.getHostName();
|
||
m_port = port;
|
||
m_path = path;
|
||
m_origin = uri.getAuthority();
|
||
m_SSLConnection = uri.isSecure() ? LCCSCF_USE_SSL : 0;
|
||
|
||
LOGI("WebSocket::init m_host: %s, m_port: %d, m_path: %s", m_host.c_str(), m_port, m_path.c_str());
|
||
|
||
int protocolCount = 0;
|
||
if (protocols && protocols->size() > 0)
|
||
{
|
||
protocolCount = protocols->size();
|
||
}
|
||
else
|
||
{
|
||
protocolCount = 1;
|
||
}
|
||
|
||
m_wsProtocols = new lws_protocols[protocolCount+1];
|
||
memset(m_wsProtocols, 0, sizeof(lws_protocols)*(protocolCount+1));
|
||
|
||
if (protocols)
|
||
{
|
||
int i = 0;
|
||
for (std::vector<std::string>::const_iterator iter = protocols->begin(); iter != protocols->end(); ++iter, ++i)
|
||
{
|
||
char* name = new char[(*iter).length()+1];
|
||
strcpy(name, (*iter).c_str());
|
||
m_wsProtocols[i].name = name;
|
||
m_wsProtocols[i].rx_buffer_size=65536;
|
||
m_wsProtocols[i].callback = WebSocketCallbackWrapper::onSocketCallback;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
char* name = new char[20];
|
||
strcpy(name, "default-protocol");
|
||
m_wsProtocols[0].name = name;
|
||
m_wsProtocols[0].rx_buffer_size=65536; //如果这里不设，则在android下当发送的数据很多的时候，会导致发送失败（返回0）
|
||
//猎刃有时候打不到怪就是因为这个（抓包看到的是发送的为原始内容，同普通socket不知道为什么，可能无关？）
|
||
m_wsProtocols[0].callback = WebSocketCallbackWrapper::onSocketCallback;
|
||
}
|
||
|
||
// WebSocket thread needs to be invoked at the end of this method.
|
||
m_wsHelper = new WsThreadHelper();
|
||
ret = m_wsHelper->createThread(*this);
|
||
|
||
return ret;
|
||
}
|
||
|
||
void WebSocket::send(const std::string& message)
|
||
{
|
||
if (m_readyState == State::OPEN)
|
||
{
|
||
// In main thread
|
||
WsMessage* msg = new WsMessage();
|
||
msg->what = WS_MSG_TO_SUBTRHEAD_SENDING_STRING;
|
||
Data* data = new Data();
|
||
data->bytes = new char[message.length()+1];
|
||
strcpy(data->bytes, message.c_str());
|
||
data->len = message.length();
|
||
msg->obj = data;
|
||
m_wsHelper->sendMessageToSubThread(msg);
|
||
}
|
||
}
|
||
|
||
void WebSocket::send(const unsigned char* binaryMsg, unsigned int len)
|
||
{
|
||
//assert(binaryMsg != nullptr && len > 0, "parameter invalid.");
|
||
|
||
if (m_readyState == State::OPEN)
|
||
{
|
||
// In main thread
|
||
WsMessage* msg = new WsMessage();
|
||
msg->what = WS_MSG_TO_SUBTRHEAD_SENDING_BINARY;
|
||
Data* data = new Data();
|
||
data->bytes = new char[len];
|
||
memcpy((void*)data->bytes, (void*)binaryMsg, len);
|
||
data->len = len;
|
||
msg->obj = data;
|
||
m_wsHelper->sendMessageToSubThread(msg);
|
||
}
|
||
}
|
||
|
||
void WebSocket::close()
|
||
{
|
||
if (m_readyState == State::CLOSING || m_readyState == State::CLOSED)
|
||
{
|
||
return;
|
||
}
|
||
|
||
LOGI("websocket connection closed by client");
|
||
//TODO 这里其实不应该设置. 原来是靠这个来关掉ws，但是实际上
|
||
//这个变量很容易被ws线程修改，导致下面join的时候卡死。
|
||
m_readyState = State::CLOSED;
|
||
|
||
m_bWantClose = true;
|
||
|
||
m_wsHelper->joinSubThread();
|
||
|
||
// onClose callback needs to be invoked at the end of this method
|
||
// since websocket instance may be deleted in 'onClose'.
|
||
if(m_delegate)
|
||
m_delegate->onClose(this);
|
||
}
|
||
|
||
WebSocket::State WebSocket::getReadyState()
|
||
{
|
||
return m_readyState;
|
||
}
|
||
|
||
int WebSocket::onSubThreadLoop()
|
||
{
|
||
if (m_readyState == State::CLOSED || m_readyState == State::CLOSING || m_bWantClose)
|
||
{
|
||
lws_context_destroy(m_wsContext);
|
||
// return 1 to exit the loop.
|
||
return 1;
|
||
}
|
||
|
||
if (m_wsContext && m_readyState != State::CLOSED && m_readyState != State::CLOSING)
|
||
{
|
||
lws_service(m_wsContext, 0);
|
||
}
|
||
|
||
// Sleep 3 ms
|
||
std::this_thread::sleep_for(std::chrono::milliseconds(3));
|
||
//boost::this_thread::sleep(boost::posix_time::milliseconds(50));
|
||
|
||
return 0;
|
||
}
|
||
|
||
void WebSocket::onSubThreadStarted(){
|
||
|
||
lws_context_creation_info info = createContextCreationInfo(m_wsProtocols, true);
|
||
m_wsContext = lws_create_context(&info);
|
||
lws_vhost* p_wsvhost = createVhost(m_wsProtocols, m_SSLConnection);
|
||
if (s_strProxy.length() > 0) {
|
||
lws_set_proxy(p_wsvhost, s_strProxy.c_str());
|
||
}
|
||
//lws_set_log_level(0xff, nullptr);
|
||
|
||
if(nullptr != m_wsContext)
|
||
{
|
||
m_readyState = State::CONNECTING;
|
||
std::string name;
|
||
for (int i = 0; m_wsProtocols[i].callback != nullptr; ++i)
|
||
{
|
||
name += (m_wsProtocols[i].name);
|
||
|
||
if (m_wsProtocols[i+1].callback != nullptr) name += ", ";
|
||
}
|
||
//m_wsInstance = libwebsocket_client_connect(m_wsContext, m_host.c_str(), m_port, m_SSLConnection,
|
||
// m_path.c_str(), m_host.c_str(), m_host.c_str(),
|
||
// name.c_str(), -1);
|
||
m_wsInstance = lws_client_connect(m_wsContext, m_host.c_str(), m_port, m_SSLConnection,
|
||
m_path.c_str(), m_host.c_str(), m_origin.c_str(),
|
||
NULL, -1);
|
||
|
||
}
|
||
}
|
||
|
||
void WebSocket::onSubThreadEnded()
|
||
{
|
||
|
||
}
|
||
|
||
int WebSocket::onSocketCallback(
|
||
struct lws *wsi,
|
||
int reason,
|
||
void *user, void *in, size_t len)
|
||
{
|
||
//CCLOG("socket callback for %d reason", reason);
|
||
//assert(m_wsContext == nullptr || ctx == m_wsContext);
|
||
//assert(m_wsInstance == nullptr || wsi == nullptr || wsi == m_wsInstance);
|
||
switch (reason)
|
||
{
|
||
case LWS_CALLBACK_DEL_POLL_FD:
|
||
case LWS_CALLBACK_PROTOCOL_DESTROY:
|
||
case LWS_CALLBACK_CLIENT_CONNECTION_ERROR:
|
||
{
|
||
WsMessage* msg = nullptr;
|
||
if (reason == LWS_CALLBACK_CLIENT_CONNECTION_ERROR
|
||
|| (reason == LWS_CALLBACK_PROTOCOL_DESTROY && m_readyState == State::CONNECTING)
|
||
|| (reason == LWS_CALLBACK_DEL_POLL_FD && m_readyState == State::CONNECTING)
|
||
)
|
||
{
|
||
msg = new WsMessage();
|
||
msg->what = WS_MSG_TO_JS_THREAD_ERROR;
|
||
m_readyState = State::CLOSING;
|
||
}
|
||
else if (reason == LWS_CALLBACK_PROTOCOL_DESTROY && m_readyState == State::CLOSING)
|
||
{
|
||
msg = new WsMessage();
|
||
msg->what = WS_MSG_TO_JS_THREAD_CLOSE;
|
||
}
|
||
|
||
if (msg)
|
||
{
|
||
m_wsHelper->sendMessageToJSThread(msg);
|
||
}
|
||
}
|
||
break;
|
||
case LWS_CALLBACK_CLIENT_ESTABLISHED:
|
||
{
|
||
WsMessage* msg = new WsMessage();
|
||
msg->what = WS_MSG_TO_JS_THREAD_OPEN;
|
||
m_readyState = State::OPEN;
|
||
|
||
/*
|
||
* start the ball rolling,
|
||
* LWS_CALLBACK_CLIENT_WRITEABLE will come next service
|
||
*/
|
||
lws_callback_on_writable( wsi);
|
||
m_wsHelper->sendMessageToJSThread(msg);
|
||
}
|
||
break;
|
||
|
||
case LWS_CALLBACK_CLIENT_WRITEABLE:
|
||
{
|
||
std::lock_guard<std::mutex> lock(*m_wsHelper->m_subThreadWsMessageQueueMutex);
|
||
|
||
std::list<WsMessage*>::iterator iter = m_wsHelper->m_subThreadWsMessageQueue->begin();
|
||
|
||
int bytesWrite = 0;
|
||
for (; iter != m_wsHelper->m_subThreadWsMessageQueue->end(); )
|
||
{
|
||
WsMessage* subThreadMsg = *iter;
|
||
|
||
if ( WS_MSG_TO_SUBTRHEAD_SENDING_STRING == subThreadMsg->what
|
||
|| WS_MSG_TO_SUBTRHEAD_SENDING_BINARY == subThreadMsg->what)
|
||
{
|
||
Data* data = (Data*)subThreadMsg->obj;
|
||
|
||
unsigned char* buf = new unsigned char[LWS_SEND_BUFFER_PRE_PADDING
|
||
+ data->len + LWS_SEND_BUFFER_POST_PADDING];
|
||
|
||
memset(&buf[LWS_SEND_BUFFER_PRE_PADDING], 0, data->len);
|
||
memcpy((char*)&buf[LWS_SEND_BUFFER_PRE_PADDING], data->bytes, data->len);
|
||
|
||
enum lws_write_protocol writeProtocol;
|
||
|
||
if (WS_MSG_TO_SUBTRHEAD_SENDING_STRING == subThreadMsg->what)
|
||
{
|
||
writeProtocol = LWS_WRITE_TEXT;
|
||
}
|
||
else
|
||
{
|
||
writeProtocol = LWS_WRITE_BINARY;
|
||
}
|
||
|
||
bytesWrite = lws_write(wsi, &buf[LWS_SEND_BUFFER_PRE_PADDING], data->len, writeProtocol);
|
||
if( bytesWrite==0){
|
||
//暂时无法发送，等会儿再试
|
||
break;
|
||
}
|
||
if( bytesWrite==0){
|
||
break;
|
||
}
|
||
if (bytesWrite < 0)
|
||
{
|
||
//发生错误了。
|
||
LOGE("WebSocket::onSocketCallback libwebsocket_write error! ");
|
||
break;
|
||
}
|
||
if (bytesWrite < data->len)
|
||
{
|
||
}
|
||
|
||
LAYA_SAFE_DELETE_ARRAY(data->bytes);
|
||
LAYA_SAFE_DELETE(data);
|
||
LAYA_SAFE_DELETE_ARRAY(buf);
|
||
}
|
||
|
||
iter = m_wsHelper->m_subThreadWsMessageQueue->erase(iter);
|
||
LAYA_SAFE_DELETE(subThreadMsg);
|
||
}
|
||
|
||
// m_wsHelper->m_subThreadWsMessageQueue->clear();
|
||
|
||
|
||
/* get notified as soon as we can write again */
|
||
|
||
lws_callback_on_writable( wsi);
|
||
}
|
||
break;
|
||
|
||
case LWS_CALLBACK_CLOSED:
|
||
{
|
||
|
||
// CCLOG("%s", "connection closing..");
|
||
|
||
m_wsHelper->quitSubThread();
|
||
|
||
if (m_readyState != State::CLOSED)
|
||
{
|
||
WsMessage* msg = new WsMessage();
|
||
m_readyState = State::CLOSED;
|
||
msg->what = WS_MSG_TO_JS_THREAD_CLOSE;
|
||
m_wsHelper->sendMessageToJSThread(msg);
|
||
}
|
||
}
|
||
break;
|
||
|
||
case LWS_CALLBACK_CLIENT_RECEIVE:
|
||
{
|
||
//bool finalfrg = lws_is_final_fragment(wsi)!=0; 这个永远都是1
|
||
const size_t remaining = lws_remaining_packet_payload(wsi);
|
||
if (in && len > 0){
|
||
if (remaining>0) {
|
||
//帧不完整
|
||
char* pData = new char[m_nCurDataLen + len];
|
||
if(m_nCurDataLen)
|
||
memcpy(pData, m_pLastData, m_nCurDataLen);
|
||
memcpy(pData + m_nCurDataLen, in, len);
|
||
|
||
if (m_pLastData) {
|
||
delete [] m_pLastData;
|
||
if (m_bLastIsBin != lws_frame_is_binary(wsi)) {
|
||
LOGE("warn:difference frame type！");
|
||
}
|
||
}
|
||
m_pLastData = pData;
|
||
m_nCurDataLen += len;
|
||
m_bLastIsBin = lws_frame_is_binary(wsi);
|
||
//append(in, len);
|
||
}
|
||
else {
|
||
char* pData =(char*) in;
|
||
size_t nLen = len;
|
||
bool needDel = false;
|
||
if (m_pLastData) {
|
||
needDel = true;
|
||
pData = new char[m_nCurDataLen+len];
|
||
memcpy(pData, m_pLastData,m_nCurDataLen);
|
||
memcpy(pData + m_nCurDataLen, in, len);
|
||
nLen += m_nCurDataLen;
|
||
delete[] m_pLastData;
|
||
m_pLastData = nullptr;
|
||
m_nCurDataLen = 0;
|
||
}
|
||
|
||
WsMessage* msg = new WsMessage();
|
||
msg->what = WS_MSG_TO_JS_THREAD_MESSAGE;
|
||
|
||
char* bytes = NULL;
|
||
Data* data = new Data();
|
||
|
||
if (lws_frame_is_binary(wsi)) {
|
||
bytes = new char[nLen];
|
||
data->isBinary = true;
|
||
}
|
||
else {
|
||
bytes = new char[nLen + 1];
|
||
bytes[nLen] = '\0';
|
||
data->isBinary = false;
|
||
}
|
||
|
||
memcpy(bytes, pData, nLen);
|
||
data->bytes = bytes;
|
||
data->len = nLen;
|
||
msg->obj = (void*)data;
|
||
|
||
if (needDel) {
|
||
delete[] pData;
|
||
}
|
||
|
||
m_wsHelper->sendMessageToJSThread(msg);
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
default:
|
||
break;
|
||
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
void WebSocket::onJSThreadReceiveMessage(WsMessage* msg)
|
||
{
|
||
if (!m_delegate)
|
||
return;
|
||
|
||
switch (msg->what) {
|
||
case WS_MSG_TO_JS_THREAD_OPEN:
|
||
{
|
||
m_delegate->onOpen(this);
|
||
}
|
||
break;
|
||
case WS_MSG_TO_JS_THREAD_MESSAGE:
|
||
{
|
||
/*
|
||
Data* data = (Data*)msg->obj;
|
||
m_delegate->onMessage(this, *data); //TODO 这个指针直接传给js，js来删除，能避免一次new和memcpy
|
||
LAYA_SAFE_DELETE_ARRAY(data->bytes);
|
||
LAYA_SAFE_DELETE(data);
|
||
*/
|
||
m_delegate->onMessage(this, *(Data*)msg->obj);
|
||
}
|
||
break;
|
||
case WS_MSG_TO_JS_THREAD_CLOSE:
|
||
{
|
||
m_delegate->onClose(this);
|
||
}
|
||
break;
|
||
case WS_MSG_TO_JS_THREAD_ERROR:
|
||
{
|
||
// FIXME: The exact error needs to be checked.
|
||
WebSocket::ErrorCode err = ErrorCode::CONNECTION_FAILURE;
|
||
m_delegate->onError(this, err);
|
||
}
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
lws_context_creation_info WebSocket::createContextCreationInfo(const struct lws_protocols* protocols, bool peerServerCert)
|
||
{
|
||
lws_context_creation_info info;
|
||
memset(&info, 0, sizeof(info));
|
||
info.port = CONTEXT_PORT_NO_LISTEN;
|
||
info.protocols = protocols;
|
||
|
||
//info.extensions = exts;
|
||
|
||
info.gid = -1;
|
||
info.uid = -1;
|
||
if (peerServerCert)
|
||
{
|
||
info.options = LWS_SERVER_OPTION_EXPLICIT_VHOSTS | LWS_SERVER_OPTION_DO_SSL_GLOBAL_INIT;
|
||
}
|
||
else
|
||
{
|
||
info.options = LWS_SERVER_OPTION_EXPLICIT_VHOSTS | LWS_SERVER_OPTION_DO_SSL_GLOBAL_INIT | LWS_SERVER_OPTION_PEER_CERT_NOT_REQUIRED;
|
||
}
|
||
info.user = this;
|
||
|
||
return info;
|
||
}
|
||
|
||
lws_vhost* WebSocket::createVhost(struct lws_protocols* protocols, int& sslConnection)
|
||
{
|
||
std::string caFileName = "cacert.pem";
|
||
#ifdef WIN32
|
||
static std::string caFilePath = gRedistPath + std::string("ca/") + caFileName;
|
||
bool isCAFileExist = fs::exists(caFilePath);
|
||
#else
|
||
static std::string caFilePath = gResourcePath + "ca/" + caFileName;
|
||
bool isCAFileExist = JCConch::s_pAssetsFiles->isFileExist(("ca/" + caFileName).c_str());
|
||
#endif
|
||
|
||
lws_context_creation_info info = createContextCreationInfo(protocols, isCAFileExist);
|
||
|
||
if (sslConnection != 0)
|
||
{
|
||
if (isCAFileExist)
|
||
{
|
||
#ifdef ANDROID
|
||
// if ca file is in the apk, try to extract it to writable path
|
||
std::string writablePath = gRedistPath;
|
||
static std::string newCaFilePath = writablePath + caFileName;
|
||
|
||
if (fs::exists(newCaFilePath))
|
||
{
|
||
LOGI("ca file already exists in apk [%s]", newCaFilePath.c_str());
|
||
info.ssl_ca_filepath = newCaFilePath.c_str();
|
||
}
|
||
else
|
||
{
|
||
char* sJSRuntime = NULL;
|
||
int nSize = 0;
|
||
if (JCConch::s_pAssetsFiles->loadFileContent(caFilePath.c_str(), sJSRuntime, nSize))
|
||
{
|
||
if (writeFileSync1(newCaFilePath.c_str(), sJSRuntime, nSize))
|
||
{
|
||
info.ssl_ca_filepath = newCaFilePath.c_str();
|
||
LOGE("copy ca file succeed");
|
||
}
|
||
else
|
||
{
|
||
LOGE("write ca file failed while copy it to apk");
|
||
sslConnection = sslConnection | LCCSCF_ALLOW_SELFSIGNED | LCCSCF_SKIP_SERVER_CERT_HOSTNAME_CHECK;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
LOGE("read ca file failed while copy it to apk");
|
||
sslConnection = sslConnection | LCCSCF_ALLOW_SELFSIGNED | LCCSCF_SKIP_SERVER_CERT_HOSTNAME_CHECK;
|
||
}
|
||
}
|
||
#else
|
||
LOGI("find ca file in [%s]", caFilePath.c_str());
|
||
info.ssl_ca_filepath = caFilePath.c_str();
|
||
#endif
|
||
}
|
||
else
|
||
{
|
||
LOGI("can not find ca file in [%s]", caFilePath.c_str());
|
||
sslConnection = sslConnection | LCCSCF_ALLOW_SELFSIGNED | LCCSCF_SKIP_SERVER_CERT_HOSTNAME_CHECK;
|
||
}
|
||
}
|
||
|
||
lws_vhost* vhost = lws_create_vhost(m_wsContext, &info);
|
||
|
||
return vhost;
|
||
}
|
||
}
|
||
|