mirror of https://github.com/axmolengine/axmol.git
643 lines
18 KiB
C++
643 lines
18 KiB
C++
/****************************************************************************
|
|
Copyright (c) 2012 greathqy
|
|
Copyright (c) 2012 cocos2d-x.org
|
|
Copyright (c) 2013-2016 Chukong Technologies Inc.
|
|
|
|
http://www.cocos2d-x.org
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
in the Software without restriction, including without limitation the rights
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
all copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
THE SOFTWARE.
|
|
****************************************************************************/
|
|
|
|
#include "network/HttpClient.h"
|
|
#include <queue>
|
|
#include <errno.h>
|
|
#include <curl/curl.h>
|
|
#include "base/CCDirector.h"
|
|
#include "platform/CCFileUtils.h"
|
|
|
|
NS_CC_BEGIN
|
|
|
|
namespace network {
|
|
|
|
#if (CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)
|
|
typedef int int32_t;
|
|
#endif
|
|
|
|
static HttpClient* _httpClient = nullptr; // pointer to singleton
|
|
|
|
typedef size_t (*write_callback)(void *ptr, size_t size, size_t nmemb, void *stream);
|
|
|
|
// Callback function used by libcurl for collect response data
|
|
static size_t writeData(void *ptr, size_t size, size_t nmemb, void *stream)
|
|
{
|
|
std::vector<char> *recvBuffer = (std::vector<char>*)stream;
|
|
size_t sizes = size * nmemb;
|
|
|
|
// add data to the end of recvBuffer
|
|
// write data maybe called more than once in a single request
|
|
recvBuffer->insert(recvBuffer->end(), (char*)ptr, (char*)ptr+sizes);
|
|
|
|
return sizes;
|
|
}
|
|
|
|
// Callback function used by libcurl for collect header data
|
|
static size_t writeHeaderData(void *ptr, size_t size, size_t nmemb, void *stream)
|
|
{
|
|
std::vector<char> *recvBuffer = (std::vector<char>*)stream;
|
|
size_t sizes = size * nmemb;
|
|
|
|
// add data to the end of recvBuffer
|
|
// write data maybe called more than once in a single request
|
|
recvBuffer->insert(recvBuffer->end(), (char*)ptr, (char*)ptr+sizes);
|
|
|
|
return sizes;
|
|
}
|
|
|
|
|
|
static int processGetTask(HttpClient* client, HttpRequest* request, write_callback callback, void *stream, long *errorCode, write_callback headerCallback, void *headerStream, char* errorBuffer);
|
|
static int processPostTask(HttpClient* client, HttpRequest* request, write_callback callback, void *stream, long *errorCode, write_callback headerCallback, void *headerStream, char* errorBuffer);
|
|
static int processPutTask(HttpClient* client, HttpRequest* request, write_callback callback, void *stream, long *errorCode, write_callback headerCallback, void *headerStream, char* errorBuffer);
|
|
static int processDeleteTask(HttpClient* client, HttpRequest* request, write_callback callback, void *stream, long *errorCode, write_callback headerCallback, void *headerStream, char* errorBuffer);
|
|
// int processDownloadTask(HttpRequest *task, write_callback callback, void *stream, int32_t *errorCode);
|
|
|
|
// Worker thread
|
|
void HttpClient::networkThread()
|
|
{
|
|
increaseThreadCount();
|
|
|
|
while (true)
|
|
{
|
|
HttpRequest *request;
|
|
|
|
// step 1: send http request if the requestQueue isn't empty
|
|
{
|
|
std::lock_guard<std::mutex> lock(_requestQueueMutex);
|
|
while (_requestQueue.empty())
|
|
{
|
|
_sleepCondition.wait(_requestQueueMutex);
|
|
}
|
|
request = _requestQueue.at(0);
|
|
_requestQueue.erase(0);
|
|
}
|
|
|
|
if (request == _requestSentinel) {
|
|
break;
|
|
}
|
|
|
|
// step 2: libcurl sync access
|
|
|
|
// Create a HttpResponse object, the default setting is http access failed
|
|
HttpResponse *response = new (std::nothrow) HttpResponse(request);
|
|
|
|
processResponse(response, _responseMessage);
|
|
|
|
|
|
// add response packet into queue
|
|
_responseQueueMutex.lock();
|
|
_responseQueue.pushBack(response);
|
|
_responseQueueMutex.unlock();
|
|
|
|
_schedulerMutex.lock();
|
|
if (nullptr != _scheduler)
|
|
{
|
|
_scheduler->performFunctionInCocosThread(CC_CALLBACK_0(HttpClient::dispatchResponseCallbacks, this));
|
|
}
|
|
_schedulerMutex.unlock();
|
|
}
|
|
|
|
// cleanup: if worker thread received quit signal, clean up un-completed request queue
|
|
_requestQueueMutex.lock();
|
|
_requestQueue.clear();
|
|
_requestQueueMutex.unlock();
|
|
|
|
_responseQueueMutex.lock();
|
|
_responseQueue.clear();
|
|
_responseQueueMutex.unlock();
|
|
|
|
decreaseThreadCountAndMayDeleteThis();
|
|
}
|
|
|
|
// Worker thread
|
|
void HttpClient::networkThreadAlone(HttpRequest* request, HttpResponse* response)
|
|
{
|
|
increaseThreadCount();
|
|
|
|
char responseMessage[RESPONSE_BUFFER_SIZE] = { 0 };
|
|
processResponse(response, responseMessage);
|
|
|
|
_schedulerMutex.lock();
|
|
if (nullptr != _scheduler)
|
|
{
|
|
_scheduler->performFunctionInCocosThread([this, response, request]{
|
|
const ccHttpRequestCallback& callback = request->getCallback();
|
|
Ref* pTarget = request->getTarget();
|
|
SEL_HttpResponse pSelector = request->getSelector();
|
|
|
|
if (callback != nullptr)
|
|
{
|
|
callback(this, response);
|
|
}
|
|
else if (pTarget && pSelector)
|
|
{
|
|
(pTarget->*pSelector)(this, response);
|
|
}
|
|
response->release();
|
|
// do not release in other thread
|
|
request->release();
|
|
});
|
|
}
|
|
_schedulerMutex.unlock();
|
|
|
|
decreaseThreadCountAndMayDeleteThis();
|
|
}
|
|
|
|
//Configure curl's timeout property
|
|
static bool configureCURL(HttpClient* client, CURL* handle, char* errorBuffer)
|
|
{
|
|
if (!handle) {
|
|
return false;
|
|
}
|
|
|
|
int32_t code;
|
|
code = curl_easy_setopt(handle, CURLOPT_ERRORBUFFER, errorBuffer);
|
|
if (code != CURLE_OK) {
|
|
return false;
|
|
}
|
|
code = curl_easy_setopt(handle, CURLOPT_TIMEOUT, HttpClient::getInstance()->getTimeoutForRead());
|
|
if (code != CURLE_OK) {
|
|
return false;
|
|
}
|
|
code = curl_easy_setopt(handle, CURLOPT_CONNECTTIMEOUT, HttpClient::getInstance()->getTimeoutForConnect());
|
|
if (code != CURLE_OK) {
|
|
return false;
|
|
}
|
|
|
|
std::string sslCaFilename = client->getSSLVerification();
|
|
if (sslCaFilename.empty()) {
|
|
curl_easy_setopt(handle, CURLOPT_SSL_VERIFYPEER, 0L);
|
|
curl_easy_setopt(handle, CURLOPT_SSL_VERIFYHOST, 0L);
|
|
} else {
|
|
curl_easy_setopt(handle, CURLOPT_SSL_VERIFYPEER, 1L);
|
|
curl_easy_setopt(handle, CURLOPT_SSL_VERIFYHOST, 2L);
|
|
curl_easy_setopt(handle, CURLOPT_CAINFO, sslCaFilename.c_str());
|
|
}
|
|
|
|
// FIXED #3224: The subthread of CCHttpClient interrupts main thread if timeout comes.
|
|
// Document is here: http://curl.haxx.se/libcurl/c/curl_easy_setopt.html#CURLOPTNOSIGNAL
|
|
curl_easy_setopt(handle, CURLOPT_NOSIGNAL, 1L);
|
|
|
|
curl_easy_setopt(handle, CURLOPT_ACCEPT_ENCODING, "");
|
|
|
|
return true;
|
|
}
|
|
|
|
class CURLRaii
|
|
{
|
|
/// Instance of CURL
|
|
CURL *_curl;
|
|
/// Keeps custom header data
|
|
curl_slist *_headers;
|
|
public:
|
|
CURLRaii()
|
|
: _curl(curl_easy_init())
|
|
, _headers(nullptr)
|
|
{
|
|
}
|
|
|
|
~CURLRaii()
|
|
{
|
|
if (_curl)
|
|
curl_easy_cleanup(_curl);
|
|
/* free the linked list for header data */
|
|
if (_headers)
|
|
curl_slist_free_all(_headers);
|
|
}
|
|
|
|
template <class T>
|
|
bool setOption(CURLoption option, T data)
|
|
{
|
|
return CURLE_OK == curl_easy_setopt(_curl, option, data);
|
|
}
|
|
|
|
/**
|
|
* @brief Inits CURL instance for common usage
|
|
* @param request Null not allowed
|
|
* @param callback Response write callback
|
|
* @param stream Response write stream
|
|
*/
|
|
bool init(HttpClient* client, HttpRequest* request, write_callback callback, void* stream, write_callback headerCallback, void* headerStream, char* errorBuffer)
|
|
{
|
|
if (!_curl)
|
|
return false;
|
|
if (!configureCURL(client, _curl, errorBuffer))
|
|
return false;
|
|
|
|
/* get custom header data (if set) */
|
|
std::vector<std::string> headers=request->getHeaders();
|
|
if(!headers.empty())
|
|
{
|
|
/* append custom headers one by one */
|
|
for (auto& header : headers)
|
|
_headers = curl_slist_append(_headers,header.c_str());
|
|
/* set custom headers for curl */
|
|
if (!setOption(CURLOPT_HTTPHEADER, _headers))
|
|
return false;
|
|
}
|
|
std::string cookieFilename = client->getCookieFilename();
|
|
if (!cookieFilename.empty()) {
|
|
if (!setOption(CURLOPT_COOKIEFILE, cookieFilename.c_str())) {
|
|
return false;
|
|
}
|
|
if (!setOption(CURLOPT_COOKIEJAR, cookieFilename.c_str())) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return setOption(CURLOPT_URL, request->getUrl())
|
|
&& setOption(CURLOPT_WRITEFUNCTION, callback)
|
|
&& setOption(CURLOPT_WRITEDATA, stream)
|
|
&& setOption(CURLOPT_HEADERFUNCTION, headerCallback)
|
|
&& setOption(CURLOPT_HEADERDATA, headerStream);
|
|
|
|
}
|
|
|
|
/// @param responseCode Null not allowed
|
|
bool perform(long *responseCode)
|
|
{
|
|
if (CURLE_OK != curl_easy_perform(_curl))
|
|
return false;
|
|
CURLcode code = curl_easy_getinfo(_curl, CURLINFO_RESPONSE_CODE, responseCode);
|
|
if (code != CURLE_OK || !(*responseCode >= 200 && *responseCode < 300)) {
|
|
CCLOGERROR("Curl curl_easy_getinfo failed: %s", curl_easy_strerror(code));
|
|
return false;
|
|
}
|
|
// Get some mor data.
|
|
|
|
return true;
|
|
}
|
|
};
|
|
|
|
//Process Get Request
|
|
static int processGetTask(HttpClient* client, HttpRequest* request, write_callback callback, void* stream, long* responseCode, write_callback headerCallback, void* headerStream, char* errorBuffer)
|
|
{
|
|
CURLRaii curl;
|
|
bool ok = curl.init(client, request, callback, stream, headerCallback, headerStream, errorBuffer)
|
|
&& curl.setOption(CURLOPT_FOLLOWLOCATION, true)
|
|
&& curl.perform(responseCode);
|
|
return ok ? 0 : 1;
|
|
}
|
|
|
|
//Process POST Request
|
|
static int processPostTask(HttpClient* client, HttpRequest* request, write_callback callback, void* stream, long* responseCode, write_callback headerCallback, void* headerStream, char* errorBuffer)
|
|
{
|
|
CURLRaii curl;
|
|
bool ok = curl.init(client, request, callback, stream, headerCallback, headerStream, errorBuffer)
|
|
&& curl.setOption(CURLOPT_POST, 1)
|
|
&& curl.setOption(CURLOPT_POSTFIELDS, request->getRequestData())
|
|
&& curl.setOption(CURLOPT_POSTFIELDSIZE, request->getRequestDataSize())
|
|
&& curl.perform(responseCode);
|
|
return ok ? 0 : 1;
|
|
}
|
|
|
|
//Process PUT Request
|
|
static int processPutTask(HttpClient* client, HttpRequest* request, write_callback callback, void* stream, long* responseCode, write_callback headerCallback, void* headerStream, char* errorBuffer)
|
|
{
|
|
CURLRaii curl;
|
|
bool ok = curl.init(client, request, callback, stream, headerCallback, headerStream, errorBuffer)
|
|
&& curl.setOption(CURLOPT_CUSTOMREQUEST, "PUT")
|
|
&& curl.setOption(CURLOPT_POSTFIELDS, request->getRequestData())
|
|
&& curl.setOption(CURLOPT_POSTFIELDSIZE, request->getRequestDataSize())
|
|
&& curl.perform(responseCode);
|
|
return ok ? 0 : 1;
|
|
}
|
|
|
|
//Process DELETE Request
|
|
static int processDeleteTask(HttpClient* client, HttpRequest* request, write_callback callback, void* stream, long* responseCode, write_callback headerCallback, void* headerStream, char* errorBuffer)
|
|
{
|
|
CURLRaii curl;
|
|
bool ok = curl.init(client, request, callback, stream, headerCallback, headerStream, errorBuffer)
|
|
&& curl.setOption(CURLOPT_CUSTOMREQUEST, "DELETE")
|
|
&& curl.setOption(CURLOPT_FOLLOWLOCATION, true)
|
|
&& curl.perform(responseCode);
|
|
return ok ? 0 : 1;
|
|
}
|
|
|
|
// HttpClient implementation
|
|
HttpClient* HttpClient::getInstance()
|
|
{
|
|
if (_httpClient == nullptr)
|
|
{
|
|
_httpClient = new (std::nothrow) HttpClient();
|
|
}
|
|
|
|
return _httpClient;
|
|
}
|
|
|
|
void HttpClient::destroyInstance()
|
|
{
|
|
if (nullptr == _httpClient)
|
|
{
|
|
CCLOG("HttpClient singleton is nullptr");
|
|
return;
|
|
}
|
|
|
|
CCLOG("HttpClient::destroyInstance begin");
|
|
auto thiz = _httpClient;
|
|
_httpClient = nullptr;
|
|
|
|
thiz->_scheduler->unscheduleAllForTarget(thiz);
|
|
thiz->_schedulerMutex.lock();
|
|
thiz->_scheduler = nullptr;
|
|
thiz->_schedulerMutex.unlock();
|
|
|
|
thiz->_requestQueueMutex.lock();
|
|
thiz->_requestQueue.pushBack(thiz->_requestSentinel);
|
|
thiz->_requestQueueMutex.unlock();
|
|
|
|
thiz->_sleepCondition.notify_one();
|
|
thiz->decreaseThreadCountAndMayDeleteThis();
|
|
|
|
CCLOG("HttpClient::destroyInstance() finished!");
|
|
}
|
|
|
|
void HttpClient::enableCookies(const char* cookieFile)
|
|
{
|
|
std::lock_guard<std::mutex> lock(_cookieFileMutex);
|
|
if (cookieFile)
|
|
{
|
|
_cookieFilename = std::string(cookieFile);
|
|
}
|
|
else
|
|
{
|
|
_cookieFilename = (FileUtils::getInstance()->getWritablePath() + "cookieFile.txt");
|
|
}
|
|
}
|
|
|
|
void HttpClient::setSSLVerification(const std::string& caFile)
|
|
{
|
|
std::lock_guard<std::mutex> lock(_sslCaFileMutex);
|
|
_sslCaFilename = caFile;
|
|
}
|
|
|
|
HttpClient::HttpClient()
|
|
: _isInited(false)
|
|
, _timeoutForConnect(30)
|
|
, _timeoutForRead(60)
|
|
, _threadCount(0)
|
|
, _cookie(nullptr)
|
|
, _requestSentinel(new HttpRequest())
|
|
{
|
|
CCLOG("In the constructor of HttpClient!");
|
|
memset(_responseMessage, 0, RESPONSE_BUFFER_SIZE * sizeof(char));
|
|
_scheduler = Director::getInstance()->getScheduler();
|
|
increaseThreadCount();
|
|
}
|
|
|
|
HttpClient::~HttpClient()
|
|
{
|
|
CC_SAFE_RELEASE(_requestSentinel);
|
|
CCLOG("HttpClient destructor");
|
|
}
|
|
|
|
//Lazy create semaphore & mutex & thread
|
|
bool HttpClient::lazyInitThreadSemaphore()
|
|
{
|
|
if (_isInited)
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
auto t = std::thread(CC_CALLBACK_0(HttpClient::networkThread, this));
|
|
t.detach();
|
|
_isInited = true;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//Add a get task to queue
|
|
void HttpClient::send(HttpRequest* request)
|
|
{
|
|
if (false == lazyInitThreadSemaphore())
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!request)
|
|
{
|
|
return;
|
|
}
|
|
|
|
request->retain();
|
|
|
|
_requestQueueMutex.lock();
|
|
_requestQueue.pushBack(request);
|
|
_requestQueueMutex.unlock();
|
|
|
|
// Notify thread start to work
|
|
_sleepCondition.notify_one();
|
|
}
|
|
|
|
void HttpClient::sendImmediate(HttpRequest* request)
|
|
{
|
|
if(!request)
|
|
{
|
|
return;
|
|
}
|
|
|
|
request->retain();
|
|
// Create a HttpResponse object, the default setting is http access failed
|
|
HttpResponse *response = new (std::nothrow) HttpResponse(request);
|
|
|
|
auto t = std::thread(&HttpClient::networkThreadAlone, this, request, response);
|
|
t.detach();
|
|
}
|
|
|
|
// Poll and notify main thread if responses exists in queue
|
|
void HttpClient::dispatchResponseCallbacks()
|
|
{
|
|
// log("CCHttpClient::dispatchResponseCallbacks is running");
|
|
//occurs when cocos thread fires but the network thread has already quited
|
|
HttpResponse* response = nullptr;
|
|
|
|
_responseQueueMutex.lock();
|
|
if (!_responseQueue.empty())
|
|
{
|
|
response = _responseQueue.at(0);
|
|
_responseQueue.erase(0);
|
|
}
|
|
_responseQueueMutex.unlock();
|
|
|
|
if (response)
|
|
{
|
|
HttpRequest *request = response->getHttpRequest();
|
|
const ccHttpRequestCallback& callback = request->getCallback();
|
|
Ref* pTarget = request->getTarget();
|
|
SEL_HttpResponse pSelector = request->getSelector();
|
|
|
|
if (callback != nullptr)
|
|
{
|
|
callback(this, response);
|
|
}
|
|
else if (pTarget && pSelector)
|
|
{
|
|
(pTarget->*pSelector)(this, response);
|
|
}
|
|
|
|
response->release();
|
|
// do not release in other thread
|
|
request->release();
|
|
}
|
|
}
|
|
|
|
// Process Response
|
|
void HttpClient::processResponse(HttpResponse* response, char* responseMessage)
|
|
{
|
|
auto request = response->getHttpRequest();
|
|
long responseCode = -1;
|
|
int retValue = 0;
|
|
|
|
// Process the request -> get response packet
|
|
switch (request->getRequestType())
|
|
{
|
|
case HttpRequest::Type::GET: // HTTP GET
|
|
retValue = processGetTask(this, request,
|
|
writeData,
|
|
response->getResponseData(),
|
|
&responseCode,
|
|
writeHeaderData,
|
|
response->getResponseHeader(),
|
|
responseMessage);
|
|
break;
|
|
|
|
case HttpRequest::Type::POST: // HTTP POST
|
|
retValue = processPostTask(this, request,
|
|
writeData,
|
|
response->getResponseData(),
|
|
&responseCode,
|
|
writeHeaderData,
|
|
response->getResponseHeader(),
|
|
responseMessage);
|
|
break;
|
|
|
|
case HttpRequest::Type::PUT:
|
|
retValue = processPutTask(this, request,
|
|
writeData,
|
|
response->getResponseData(),
|
|
&responseCode,
|
|
writeHeaderData,
|
|
response->getResponseHeader(),
|
|
responseMessage);
|
|
break;
|
|
|
|
case HttpRequest::Type::DELETE:
|
|
retValue = processDeleteTask(this, request,
|
|
writeData,
|
|
response->getResponseData(),
|
|
&responseCode,
|
|
writeHeaderData,
|
|
response->getResponseHeader(),
|
|
responseMessage);
|
|
break;
|
|
|
|
default:
|
|
CCASSERT(true, "CCHttpClient: unknown request type, only GET and POSt are supported");
|
|
break;
|
|
}
|
|
|
|
// write data to HttpResponse
|
|
response->setResponseCode(responseCode);
|
|
if (retValue != 0)
|
|
{
|
|
response->setSucceed(false);
|
|
response->setErrorBuffer(responseMessage);
|
|
}
|
|
else
|
|
{
|
|
response->setSucceed(true);
|
|
}
|
|
}
|
|
|
|
void HttpClient::increaseThreadCount()
|
|
{
|
|
_threadCountMutex.lock();
|
|
++_threadCount;
|
|
_threadCountMutex.unlock();
|
|
}
|
|
|
|
void HttpClient::decreaseThreadCountAndMayDeleteThis()
|
|
{
|
|
bool needDeleteThis = false;
|
|
_threadCountMutex.lock();
|
|
--_threadCount;
|
|
if (0 == _threadCount)
|
|
{
|
|
needDeleteThis = true;
|
|
}
|
|
|
|
_threadCountMutex.unlock();
|
|
if (needDeleteThis)
|
|
{
|
|
delete this;
|
|
}
|
|
}
|
|
|
|
void HttpClient::setTimeoutForConnect(int value)
|
|
{
|
|
std::lock_guard<std::mutex> lock(_timeoutForConnectMutex);
|
|
_timeoutForConnect = value;
|
|
}
|
|
|
|
int HttpClient::getTimeoutForConnect()
|
|
{
|
|
std::lock_guard<std::mutex> lock(_timeoutForConnectMutex);
|
|
return _timeoutForConnect;
|
|
}
|
|
|
|
void HttpClient::setTimeoutForRead(int value)
|
|
{
|
|
std::lock_guard<std::mutex> lock(_timeoutForReadMutex);
|
|
_timeoutForRead = value;
|
|
}
|
|
|
|
int HttpClient::getTimeoutForRead()
|
|
{
|
|
std::lock_guard<std::mutex> lock(_timeoutForReadMutex);
|
|
return _timeoutForRead;
|
|
}
|
|
|
|
const std::string& HttpClient::getCookieFilename()
|
|
{
|
|
std::lock_guard<std::mutex> lock(_cookieFileMutex);
|
|
return _cookieFilename;
|
|
}
|
|
|
|
const std::string& HttpClient::getSSLVerification()
|
|
{
|
|
std::lock_guard<std::mutex> lock(_sslCaFileMutex);
|
|
return _sslCaFilename;
|
|
}
|
|
|
|
}
|
|
|
|
NS_CC_END
|
|
|
|
|