void HttpBase::Post(IHttpHandler * handler, const char * url, const char * field) {
SafeSprintf(_url, sizeof(_url), "%s", url);
SafeSprintf(_field, sizeof(_field), "%s", field);
_type = HT_POST;
handler->SetBase(this);
_handler = handler;
}
void Redis::Append(CommandBuff& buf, float val) {
char temp[32] = { 0 };
SafeSprintf(temp, sizeof(temp), "%.2f", val);
SafeSprintf(buf.data + buf.size, sizeof(buf.data) - buf.size, "$%d\r\n%s\r\n", (s32)strlen(temp), temp);
buf.size += (s32)strlen(buf.data + buf.size);
}
//初始化
bool __cdecl CTableFrameSink::InitTableFrameSink(IUnknownEx * pIUnknownEx)
{
//查询接口
ASSERT(pIUnknownEx!=NULL);
m_pITableFrame=QUERY_OBJECT_PTR_INTERFACE(pIUnknownEx,ITableFrame);
if (m_pITableFrame==NULL) return false;
//控制接口
m_pITableFrameControl=QUERY_OBJECT_PTR_INTERFACE(pIUnknownEx,ITableFrameControl);
if (m_pITableFrameControl==NULL) return false;
m_pITableFrameManager=QUERY_OBJECT_PTR_INTERFACE(pIUnknownEx,ITableFrameManager);
if (m_pITableFrameControl==NULL) return false;
//获取参数
m_pGameServiceOption=m_pITableFrame->GetGameServiceOption();
ASSERT(m_pGameServiceOption!=NULL);
char szLogFileName[1024] = {0};
SafeSprintf(szLogFileName,"%02d-桌子",(m_pITableFrame->GetTableID()+1));
char szLogDir[128]={0};
SafeSprintf(szLogDir,"%d[%s]",m_pGameServiceOption->wServerID,m_pGameServiceOption->szGameRoomName);
m_lCellScore = m_pGameServiceOption->lCellScore;
m_oLog.Init("Ratiox",szLogDir,szLogFileName);
m_oLog.Log("==日志启动完毕==");
ReadIniCfg();
m_pITableFrame->SetGameTimer(IDI_TIME_READCFG , 5*60*1000 , -1 , 0);
m_oContral.Init(m_pITableFrame , &m_oLog , m_pGameServiceOption->lCellScore , m_pGameServiceOption->wRevenue);
srand((unsigned)time(NULL));
UpdateTask();
return true;
}
HXBOOL CHXGUID::Get(char* pBuffer, INT32 bufLen)
{
#if !defined(HELIX_FEATURE_FULLGUID)
HXBOOL bRet = FALSE;
if (pBuffer && strlen(pBuffer) > 8)
{
// GUID is an enum
SafeSprintf(pBuffer, bufLen,"%.8lX",m_guid);
}
return bRet;
#else /* #if defined(_STATICALLY_LINKED) && !defined(HELIX_FEATURE_FULLGUID) */
if (bufLen < sizeof(GUID) * 2 + 4)
return(FALSE);
// Write out the first 3 Data fields seperated by dashes and then move to the end of the buffer
SafeSprintf(pBuffer, bufLen,"%.8lX-%.4hX-%.4hX-",m_guid.Data1,m_guid.Data2,m_guid.Data3);
bufLen -= strlen(pBuffer); pBuffer += strlen(pBuffer);
// Loop through the characters in the 4th data field printing them into the buffer
for (int i=0; i < CHARS_FOR_GUID_DATA4; i++)
{
SafeSprintf(pBuffer, bufLen,"%.2lX",(UINT32)m_guid.Data4[i]);
pBuffer += 2;
bufLen -= 2;
}
return(TRUE);
#endif /* #if defined(_STATICALLY_LINKED) && !defined(HELIX_FEATURE_FULLGUID) #else */
}
void Redis::Append(CommandBuff& buf, const void * val, const s32 size) {
SafeSprintf(buf.data + buf.size, sizeof(buf.data) - buf.size, "$%d\r\n", size);
buf.size += (s32)strlen(buf.data + buf.size);
SafeMemcpy(buf.data + buf.size, sizeof(buf.data) - buf.size, val, size);
buf.size += size;
SafeSprintf(buf.data + buf.size, sizeof(buf.data) - buf.size, "\r\n");
buf.size += (s32)strlen(buf.data + buf.size);
}
void ListFileInDirection(const char * path, const char * extension, const std::function<void(const char *, const char *)> &f) {
#ifdef WIN32
WIN32_FIND_DATA finder;
char tmp[512] = { 0 };
SafeSprintf(tmp, sizeof(tmp), "%s/*.*", path);
HANDLE handle = FindFirstFile(path, &finder);
if (INVALID_HANDLE_VALUE == handle)
return;
while (FindNextFile(handle, &finder)) {
if (strcmp(finder.cFileName, ".") == 0 || strcmp(finder.cFileName, "..") == 0)
continue;
SafeSprintf(tmp, sizeof(tmp), "%s/%s", path, finder.cFileName);
if (finder.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
ListFileInDirection(tmp, extension, f);
else {
if (0 == strcmp(extension, PathFindExtension(finder.cFileName))) {
PathRemoveExtension(finder.cFileName);
f(finder.cFileName, tmp);
}
}
}
#else
DIR * dp = opendir(path);
if (dp == nullptr)
return;
struct dirent * dirp;
while ((dirp = readdir(dp)) != nullptr) {
if (dirp->d_name[0] == '.')
continue;
char tmp[256] = { 0 };
SafeSprintf(tmp, sizeof(tmp), "%s/%s", path, dirp->d_name);
struct stat st;
if (stat(tmp, &st) == -1)
continue;
if (S_ISDIR(st.st_mode))
ListFileInDirection(tmp, extension, f);
else {
if (0 == strcmp(extension, GetFileExt(dirp->d_name))) {
char name[256];
SafeSprintf(name, sizeof(name), "%s", dirp->d_name);
char * dot = strrchr(name, '.');
if (dot != nullptr)
*dot = 0;
f(name, tmp);
}
}
}
#endif
}
const char*
SMPTETimeCode::toString()
{
char strBuf[12]; /* Flawfinder: ignore */
SafeSprintf(strBuf, sizeof(strBuf), "%02d:%02d:%02d",
m_hour, m_minute, m_second);
if(m_frame > 0)
SafeSprintf(&strBuf[8], sizeof(strBuf)-8, ".%02d", m_frame);
m_asString = strBuf;
return m_asString;
}
void Slave::StartNode(IKernel * kernel, const char * cmd) {
char process[MAX_CMD_LEN];
#ifdef WIN32
SafeSprintf(process, sizeof(process), "%s/%s.exe", tools::GetAppPath(), EXECUTE_NAME);
STARTUPINFO si = { sizeof(si) };
si.dwFlags = STARTF_USESHOWWINDOW;
si.wShowWindow = TRUE;
si.lpTitle = (char*)cmd;
PROCESS_INFORMATION pi;
BOOL ret = CreateProcess(process, (char*)cmd, nullptr, nullptr, false, CREATE_NEW_CONSOLE, nullptr, nullptr, &si, &pi);
OASSERT(ret, "create process failed");
::CloseHandle(pi.hThread);
::CloseHandle(pi.hProcess);
#else
SafeSprintf(process, sizeof(process), "%s/%s", tools::GetAppPath(), EXECUTE_NAME);
char args[MAX_CMD_LEN];
SafeSprintf(args, sizeof(args), cmd);
char * p[MAX_CMD_ARGS_COUNT];
SafeMemset(p, sizeof(p), 0, sizeof(p));
p[0] = EXECUTE_NAME;
s32 idx = 1;
char * checkPtr = args;
char * innderPtr = nullptr;
while ((p[idx] = strtok_r(checkPtr, " ", &innderPtr)) != nullptr) {
++idx;
checkPtr = nullptr;
}
pid_t pid;
pid = fork();
if (pid < 0) {
OASSERT(false, "start process failed");
}
else if (pid == 0) {
pid = fork();
if (pid == 0)
execv(process, p);
else
exit(0);
}
else {
s32 status;
waitpid(pid, &status, 0);
}
#endif
}
void Battle::requestpve() {
g_pEventEngine->BundlerCall(BUND_ID_PLANE_HOLD_FIRE, this, sizeof(this));
char szUrl[256] = {0};
SafeSprintf(szUrl, sizeof(szUrl), SERVER::countpve_url, g_uid.c_str(), g_token.c_str(), 10);
g_pHttpEngine->HGetRequest(HTTP_REQUEST_ID_COUNT_PVE, szUrl, this, NULL, 0);
unschedule(schedule_selector(Battle::collidtion));
}
void
HSPErrorSink::ConvertErrorToString(const ULONG32 ulHXCode, char* pszBuffer, UINT32 ulBufLen)
{
IHXErrorMessages* pErrMsg = NULL;
if( !pszBuffer)
return;
pszBuffer[0]='\0';
HX_ASSERT(m_pPlayer);
if( m_pPlayer)
{
m_pPlayer->QueryInterface(IID_IHXErrorMessages, (void**)&pErrMsg);
if( pErrMsg )
{
IHXBuffer* pMessage = pErrMsg->GetErrorText(ulHXCode);
if( pMessage )
{
SafeStrCpy( pszBuffer, (const char*)pMessage->GetBuffer(), (int)ulBufLen);
pMessage->Release();
}
}
}
HX_RELEASE(pErrMsg);
if( strlen(pszBuffer)==0 )
{
SafeSprintf( pszBuffer, (int) ulBufLen, "Can't convert error code %p - please find corresponding HXR code in common/include/hxresult.h", ulHXCode );
}
}
void CNet::DealAcceptEvent(struct iocp_event * pEvent) {
ASSERT(m_szCallAddress[CALL_REMOTE_CONNECTED]);
if (m_szCallAddress[CALL_REMOTE_CONNECTED] != NULL) {
if (ERROR_SUCCESS == pEvent->nerron) {
s32 nConnectID = m_ConnectPool.CreateID();
m_ConnectPool[nConnectID]->s = pEvent->s;
SafeSprintf(m_ConnectPool[nConnectID]->szIP, sizeof(m_ConnectPool[nConnectID]->szIP),
"%s", inet_ntoa(pEvent->remote.sin_addr));
m_ConnectPool[nConnectID]->nPort = ntohs(pEvent->remote.sin_port);
m_szCallAddress[CALL_REMOTE_CONNECTED](nConnectID, pEvent->p, 0);
pEvent->event = EVENT_ASYNC_RECV;
pEvent->wbuf.buf = pEvent->buff;
pEvent->wbuf.len = sizeof(pEvent->buff);
m_ConnectPool[nConnectID]->pContext = pEvent->p;
pEvent->p = m_ConnectPool[nConnectID];
s32 err;
if (ERROR_NO_ERROR != async_recv(pEvent, &err, pEvent->p)) {
NET_ERROR("async_recv error %d code %d", err, pEvent->nerron);
SafeShutdwon(pEvent, CSD_BOTH);
return;
}
} else {
safe_close(pEvent);
}
}
}
int
Windows_dir_list::is_empty()
{
int isEmpty = 1;
char new_path[_MAX_PATH+10]; /* Flawfinder: ignore */
HANDLE f_handle = INVALID_HANDLE_VALUE;
WIN32_FIND_DATA f_info;
SafeSprintf(new_path, _MAX_PATH+10, "%s/*.*", _path);
f_handle = FindFirstFile(OS_STRING(new_path), &f_info);
if (f_handle == INVALID_HANDLE_VALUE)
{
do
{
if (valid_file_name(OS_STRING(f_info.cFileName)))
isEmpty = 0;
}
while (isEmpty && (FindNextFile(f_handle, &f_info) != 0));
}
else
_error = EINVAL;
FindClose(f_handle);
return isEmpty;
}
BOOL TimeDriver::DateTimeToString( const INT64& time, LPSTR& buf, size_t& len )
{
SYSTEMTIME st;
ToSystemTime( time, &st );
return SafeSprintf( buf, len, "%4d/%02d/%02d %02d:%02d:%02d.%03d", st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond, st.wMilliseconds );
}
const char*
NPTime::toString()
{
char strBuf[80]; /* Flawfinder: ignore */
if(m_lMicroSecond > 0)
{
HX_ASSERT(m_lMicroSecond < USECS_PER_SEC);
SafeSprintf(strBuf, sizeof(strBuf), "%ld.%06d", m_lSecond, m_lMicroSecond);
}
else
{
SafeSprintf(strBuf, sizeof(strBuf), "%ld", m_lSecond);
}
m_asString = strBuf;
return m_asString;
}
extern void sprintsym( SYMBOL sym, char s[], int sBufLen)
{
char ctype[80]; /* Flawfinder: ignore */
sprinttype( sym.type, ctype, 80);
SafeSprintf(s, sBufLen, "%s =%4d", ctype, sym.value);
return;
}
void Gate::BuildToken(char * token, s32 size, const TokenData& data) {
char checkBuf[1024];
SafeMemcpy(checkBuf, sizeof(checkBuf), &data, sizeof(TokenData));
SafeSprintf(checkBuf + sizeof(TokenData), sizeof(checkBuf) - sizeof(TokenData), "%s", _tokenKey.GetString());
MD5 md5;
md5.update(checkBuf, sizeof(TokenData) + _tokenKey.Length());
std::string sign = md5.toString();
char buf[1024];
SafeMemcpy(buf, sizeof(buf), &data, sizeof(TokenData));
SafeSprintf(buf + sizeof(TokenData), sizeof(buf) - sizeof(TokenData), "%s", sign.c_str());
u32 outSize = size;
s32 ret = Base64Encode((u8*)buf, (u32)(sizeof(TokenData) + sign.size()), token, &outSize);
OASSERT(ret == BASE64_OK, "wtf");
token[outSize] = 0;
}
bool ObjectMgr::Initialize(IKernel * kernel) {
_kernel = kernel;
_nextTypeId = 1;
char path[512] = { 0 };
SafeSprintf(path, sizeof(path), "%s/config/object.xml", tools::GetAppPath());
olib::XmlReader conf;
if (!conf.LoadXml(path)) {
OASSERT(false, "load object.xml failed");
return false;
}
if (conf.Root().IsExist("prop")) {
const olib::IXmlObject& props = conf.Root()["prop"];
for (s32 i = 0; i < props.Count(); ++i)
_defines[props[i].GetAttributeString("name")] = (1 << i);
}
if (conf.Root().IsExist("table")) {
const olib::IXmlObject& tables = conf.Root()["table"];
for (s32 i = 0; i < tables.Count(); ++i) {
TableDescriptor * tableModel = NEW TableDescriptor();
const char * name = tables[i].GetAttributeString("name");
if (!tableModel->LoadFrom(tables[i]))
return false;
_tableModels[tools::CalcStringUniqueId(name)] = tableModel;
}
}
SafeSprintf(path, sizeof(path), "%s/config/dccenter/", tools::GetAppPath());
tools::ListFileInDirection(path, ".xml", [this](const char * name, const char * path) {
if (_namePathMap.end() != _namePathMap.find(name)) {
OASSERT(false, "prop xml name repeated");
return;
}
_namePathMap.insert(std::make_pair(name, path));
});
for (auto itr = _namePathMap.begin(); itr != _namePathMap.end(); ++itr)
CreateTemplate(kernel, itr->first.GetString());
return true;
}
STRING ceefit_call_spec FIXTURE::RUNTIME::d(fitINT64 scale) const
{
fitINT64 report = elapsed / scale;
elapsed -= report * scale;
STRING out;
SafeSprintf(out, L"%lld", report);
return out;
}
// Parse bitstring "vlc", return length in "bits" and value in "codeword"
static int parse_bits( char vlc[], /* String with bit pattern */
int strmax, /* Max characters in "vlc" excluding terminating null */
int maxbits, /* Max # bits in codeword */
int * bits, /* Returns # bits; 0 < bits < maxbits+1 */
int * codeword, /* Returns codeword */
int minBits // Min # bits in codeword
)
{
int j, c;
char msg[120]; /* Flawfinder: ignore */
*bits = 0, j = 0, *codeword = 0;
c = vlc[j];
while (c != 0) {
if (c == '0' || c == '1') {
*codeword <<= 1;
++(*bits);
if (c == '1') {
++(*codeword);
}
} else if (isspace(c) == 0) { /* Found illegal character */
SafeSprintf(msg, 120, "parse_bits - Illegal string: %s", vlc);
H261ErrMsg( msg );
return( H261_ERROR );
}
c = vlc[++j];
}
if (j > strmax) {
SafeSprintf(msg, 120, "Too long string: %s", vlc);
H261ErrMsg( msg );
return( H261_ERROR );
}
if (*bits > maxbits || *bits < minBits) {
SafeSprintf(msg, 120, "Illegal string: %s", vlc);
H261ErrMsg( msg );
return( H261_ERROR );
}
return (OK);
}
void Harbor::AddNodeListener(INodeListener * listener, const char * debug) {
#ifdef _DEBUG
auto itr = std::find_if(_listeners.begin(), _listeners.end(), [listener](const NodeListenerUnit& unit) -> bool {
return unit.listener == listener;
});
OASSERT(itr == _listeners.end(), "node listener is already add");
#endif
NodeListenerUnit unit;
unit.listener = listener;
SafeSprintf(unit.debug, sizeof(unit.debug), debug);
_listeners.push_back(unit);
}
void Slave::StartNewNode(IKernel * kernel, const char * name, const char * cmd, const s32 nodeType, const s32 nodeId) {
std::string tmp(cmd);
std::string::size_type pos = tmp.find(EXECUTE_CMD_PORT);
while (pos != std::string::npos) {
OASSERT(_startPort < _endPort, "port is not enough");
char portStr[64];
SafeSprintf(portStr, sizeof(portStr), "%d", _startPort++);
tmp.replace(pos, EXECUTE_CMD_PORT_SIZE, portStr);
pos = tmp.find(EXECUTE_CMD_PORT);
}
pos = tmp.find(EXECUTE_CMD_OUT_PORT);
while (pos != std::string::npos) {
OASSERT(_startOutPort < _endOutPort, "out port is not enough");
char portStr[64];
SafeSprintf(portStr, sizeof(portStr), "%d", _startOutPort++);
tmp.replace(pos, EXECUTE_CMD_OUT_PORT_SIZE, portStr);
pos = tmp.find(EXECUTE_CMD_OUT_PORT);
}
pos = tmp.find(EXECUTE_CMD_ID);
if (pos != std::string::npos) {
char idStr[64];
SafeSprintf(idStr, sizeof(idStr), "%d", nodeId);
tmp.replace(pos, EXECUTE_CMD_ID_SIZE, idStr);
}
s64 node = (((s64)nodeType) << 32) | nodeId;
SafeSprintf(_cmds[node].cmd, MAX_CMD_LEN, tmp.c_str());
StartNode(kernel, _cmds[node].cmd);
}
Windows_dir_list::Windows_dir_list(const char* path) :
_file_handle(INVALID_HANDLE_VALUE),
_cur_filename(0),
_next_error(0),
_path(new_string(path))
{
char new_path[_MAX_PATH+10]; /* Flawfinder: ignore */
SafeSprintf(new_path, _MAX_PATH+10, "%s\\*.*", _path);
_file_handle = FindFirstFile(OS_STRING(new_path), &_file_info);
if (_file_handle == INVALID_HANDLE_VALUE)
_error = EINVAL;
}
BOOL TimeDriver::TimeSpanToString( const INT64& ticks, LPSTR& buf, size_t& len )
{
UINT64 ticksAbs;
UINT64 rest;
if(ticks < 0)
{
ticksAbs = -ticks;
Utility_SafeSprintf( buf, len, "-" );
}
else
{
ticksAbs = ticks;
}
rest = ticksAbs % ( 1000 * TIME_CONVERSION__TICKUNITS);
ticksAbs = ticksAbs / ( 1000 * TIME_CONVERSION__TICKUNITS); // Convert to seconds.
if(ticksAbs > TIME_CONVERSION__ONEDAY) // More than one day.
{
Utility_SafeSprintf( buf, len, "%d.", (INT32)(ticksAbs / TIME_CONVERSION__ONEDAY) ); ticksAbs %= TIME_CONVERSION__ONEDAY;
}
SafeSprintf( buf, len, "%02d:", (INT32)(ticksAbs / TIME_CONVERSION__ONEHOUR) ); ticksAbs %= TIME_CONVERSION__ONEHOUR ;
SafeSprintf( buf, len, "%02d:", (INT32)(ticksAbs / TIME_CONVERSION__ONEMINUTE)); ticksAbs %= TIME_CONVERSION__ONEMINUTE;
SafeSprintf( buf, len, "%02d" , (INT32)(ticksAbs / TIME_CONVERSION__ONESECOND)); ticksAbs %= TIME_CONVERSION__ONESECOND;
ticksAbs = (UINT32)rest;
if(ticksAbs)
{
SafeSprintf( buf, len, ".%07d", (UINT32)ticksAbs );
}
return len != 0;
}
void CSelectModel::CConnect(const char * pStrIP, const s32 nPort, const void * pContext, const s32 nSize) {
CSEvent * pEvent = m_EventPool.Create();
ASSERT(pEvent);
pEvent->nEventType = NET_EVENT_CONNECT;
RemoteInfo info;
SafeSprintf(info.szIP, sizeof(info.szIP), "%s", pStrIP);
info.nPort = nPort;
pEvent->stream.in(&info, sizeof(info));
pEvent->stream.in(&nSize, sizeof(nSize));
if (nSize != 0) {
pEvent->stream.in(pContext, nSize);
}
m_Queue[QUEUE_TYPE_IN].add(pEvent);
}
// Workhorse construction method
HXBOOL CAsyncNetThread::Create()
{
char szClassName[MAX_WND_CLASS_LENGTH]; /* Flawfinder: ignore */
SafeSprintf(szClassName, MAX_WND_CLASS_LENGTH, OS_STRING("%s%d"),
WND_CLASS_BASE, &zm_bClassRegistered);
if (!zm_bClassRegistered)
{
WNDCLASS internalClass;
OS_STRING_TYPE osstrClassName(szClassName);
// First register our window class
internalClass.style = 0;
internalClass.lpfnWndProc = CAsyncNetThread::AsyncNotifyProc;
internalClass.cbClsExtra = 0;
internalClass.cbWndExtra = sizeof(this);
internalClass.hInstance = m_hInst; // Use app's instance
internalClass.hIcon = 0;
internalClass.hCursor = 0;
internalClass.hbrBackground = 0;
internalClass.lpszMenuName = NULL;
internalClass.lpszClassName = osstrClassName;
zm_bClassRegistered = RegisterClass(&internalClass);
if(!zm_bClassRegistered)
{
UnregisterClass(OS_STRING(szClassName), m_hInst);
zm_bClassRegistered = RegisterClass(&internalClass);
}
}
// Now create an instance of the window
m_hWnd = ::CreateWindow(OS_STRING(szClassName), OS_STRING("RealMedia Internal Messages"),
WS_OVERLAPPED, 0, 0, 0, 0, NULL, NULL, m_hInst, this);
if (!m_hWnd)
{
return (FALSE);
}
return (TRUE);
}
bool Gate::CheckToken(const char * token, TokenData& data, bool login) {
u8 buf[1024];
u32 size = 1023;
if (BASE64_OK != Base64Decode(token, (u32)strlen(token), buf, &size))
return false;
buf[size] = 0;
data = *(TokenData*)buf;
const char * sign = (const char *)(buf + sizeof(TokenData));
char checkBuf[1024];
SafeMemcpy(checkBuf, sizeof(checkBuf), buf, sizeof(TokenData));
SafeSprintf(checkBuf + sizeof(TokenData), sizeof(checkBuf) - sizeof(TokenData), "%s", login ? _loginKey.GetString() : _tokenKey.GetString());
MD5 md5;
md5.update(checkBuf, sizeof(TokenData) + login ? _loginKey.Length() : _tokenKey.Length());
if (strcmp(md5.toString().c_str(), sign) != 0)
return false;
return true;
}
bool Redis::Call(const s64 id, const char* proc, const s32 keyCount, const OArgs& args, const std::function<bool(IKernel *, const IRedisResult *)>& f) {
if (s_contexts.empty())
return false;
Ping(s_kernel, id);
if (!LoadScript(s_kernel, id, proc))
return false;
CommandBuff buf;
buf.size = 0;
const char * scriptId = s_contexts[id % s_contexts.size()].scriptIds[proc].GetString();
s32 len = (s32)strlen(scriptId);
SafeSprintf(buf.data + buf.size, sizeof(buf.data) - buf.size, "*%d\r\n$7\r\nEVALSHA\r\n$%d\r\n%s\r\n", args.Count() + 2, len, scriptId);
buf.size += (s32)strlen(buf.data + buf.size);
Append(buf, args);
s_contexts[id % s_contexts.size()].ctx->obuf = buf.data;
redisReply * reply = NULL;
redisGetReply(s_contexts[id % s_contexts.size()].ctx, (void**)&reply);
if (NULL == reply) {
return false;
}
if (REDIS_REPLY_ERROR == reply->type || REDIS_REPLY_NIL == reply->type) {
freeReplyObject(reply);
return false;
}
bool ret = true;
if (f) {
RedisCallResult rst(reply);
ret = f(s_kernel, &rst);
}
freeReplyObject(reply);
return ret;
}
bool Redis::Exec(const s64 id, const char* command, const OArgs& args, const std::function<bool(IKernel *, const IRedisResult *)>& f) {
if (s_contexts.empty())
return false;
Ping(s_kernel, id);
CommandBuff buf;
buf.size = 0;
SafeSprintf(buf.data + buf.size, sizeof(buf.data) - buf.size, "*%d\r\n$%d\r\n%s\r\n", args.Count() + 1, strlen(command), command);
buf.size += (s32)strlen(buf.data + buf.size);
Append(buf, args);
s_contexts[id % s_contexts.size()].ctx->obuf = buf.data;
redisReply * reply = NULL;
redisGetReply(s_contexts[id % s_contexts.size()].ctx, (void**)&reply);
if (NULL == reply) {
return false;
}
if (REDIS_REPLY_ERROR == reply->type || REDIS_REPLY_NIL == reply->type) {
freeReplyObject(reply);
return false;
}
bool ret = true;
if (f) {
RedisCallResult rst(reply);
ret = f(s_kernel, &rst);
}
freeReplyObject(reply);
return ret;
}
HXASMStream::HXASMStream(HXStream* pStream, HXSource* pSource)
: m_bTimeStampDeliveryMode(FALSE)
, m_bInitialSubscribe(TRUE)
, m_bHasExpression(FALSE)
, m_bEndOneRuleEndAll(FALSE)
, m_ulLastLimitBandwidth(0xffffffff)
, m_lRefCount(0)
, m_nNumRules(0)
, m_pAtomicRuleChange(0)
, m_pRuleBook(0)
, m_pLossCB(0)
, m_ulLossCBHandle(0)
, m_ulBandwidthAllocation(0)
, m_ulFixedBandwidth(0)
, m_pSubInfo(0)
, m_ulRuleBw(0)
, m_ulRulePreData(0)
, m_ulCurrentPreData(0)
, m_ulCurrentBandwidth(0)
, m_ulLastBandwidth(0)
, m_bRuleTimeStampDelivery(0)
, m_ulSubscribedBw(0)
, m_lBias(0)
, m_bStartRecalc(FALSE)
, m_pSubList(0)
, m_pSubscriptionVariables(0)
, m_pRuleSubscribeStatus(NULL)
, m_pASMRuleState(NULL)
, m_pRuleEnableState(NULL)
, m_bSubsLocked(FALSE)
#ifndef GOLD
, m_pEM(0)
#endif
{
m_pStreamSinkMap = new CHXMapPtrToPtr;
UINT32 ulStreamID;
IHXPlayer* pPlayer;
pStream->GetID(ulStreamID);
m_pSource = pSource;
m_pSource->AddRef();
m_pHeader = pStream->GetHeader();
m_uStreamNumber = pStream->GetStreamNumber();
/* Hold onto some useful interfaces */
m_pSource->GetPlayer(pPlayer);
pPlayer->QueryInterface(IID_IHXRegistry, (void **)&m_pRegistry);
pPlayer->QueryInterface(IID_IHXScheduler, (void **)&m_pScheduler);
pPlayer->QueryInterface(IID_IHXCommonClassFactory, (void **)&m_pCCF);
pPlayer->Release();
/*
* WARNING! You must update all interfaces queried off the source
* in ResetASMSource().
*/
m_pSource->QueryInterface(IID_IHXASMSource, (void **)&m_pASMSource);
m_pSource->QueryInterface(IID_IHXAtomicRuleChange,
(void **)&m_pAtomicRuleChange);
#ifndef GOLD
pPlayer->QueryInterface(IID_IHXErrorMessages, (void **)&m_pEM);
#endif
UINT32 ulEndOneruleEndAll = 0;
if (m_pHeader->GetPropertyULONG32("EndOneRuleEndAll", ulEndOneruleEndAll) == HXR_OK)
{
m_bEndOneRuleEndAll = (ulEndOneruleEndAll == 1);
}
/* temporary hack to properly shut down RA and RV streams with end time */
else
{
IHXBuffer* pMimeType = NULL;
m_pHeader->GetPropertyCString("MimeType", pMimeType);
if (pMimeType &&
((::strcasecmp((const char*) pMimeType->GetBuffer(), REALAUDIO_MIME_TYPE) == 0) ||
(::strcasecmp((const char*) pMimeType->GetBuffer(), REALAUDIO_MULTIRATE_MIME_TYPE) == 0) ||
(::strcasecmp((const char*) pMimeType->GetBuffer(), REALVIDEO_MIME_TYPE) == 0) ||
(::strcasecmp((const char*) pMimeType->GetBuffer(), REALVIDEO_MULTIRATE_MIME_TYPE) == 0)))
{
m_bEndOneRuleEndAll = TRUE;
}
HX_RELEASE(pMimeType);
}
/* Extract RuleBook from the stream header */
IHXBuffer* pRuleBook = NULL;
m_pHeader->GetPropertyCString("ASMRuleBook", pRuleBook);
if (pRuleBook)
{
m_pRuleBook = new ASMRuleBook (m_pCCF, (const char *)pRuleBook->GetBuffer());
m_nNumRules = m_pRuleBook->GetNumRules();
m_ulRuleBw = new UINT32[m_nNumRules];
m_ulRulePreData = new UINT32[m_nNumRules];
m_bRuleTimeStampDelivery = new HXBOOL[m_nNumRules];
m_pSubInfo = new HXBOOL[m_nNumRules];
m_pRuleSubscribeStatus = new HXBOOL[m_nNumRules];
m_pRuleEnableState = new RuleEnableState[m_nNumRules];
for (UINT16 i = 0; i < m_nNumRules; i++)
{
IHXValues* pValues;
IHXBuffer* pBuffer;
m_pRuleBook->GetProperties(i, pValues);
m_ulRuleBw[i] = 0;
m_ulRulePreData[i] = 0;
m_bRuleTimeStampDelivery[i] = FALSE;
m_pRuleEnableState[i] = resEnabled;
if (HXR_OK == pValues->GetPropertyCString("PreData",
pBuffer))
{
m_ulRulePreData[i] = atoi((char*)pBuffer->GetBuffer());
pBuffer->Release();
}
if (HXR_OK == pValues->GetPropertyCString("AverageBandwidth",
pBuffer))
{
m_ulRuleBw[i] = atoi((char*)pBuffer->GetBuffer());
pBuffer->Release();
}
else if (HXR_OK == pValues->GetPropertyCString("TimeStampDelivery",
pBuffer))
{
if ((pBuffer->GetBuffer()[0] == 'T') ||
(pBuffer->GetBuffer()[0] == 't'))
{
// Handle TimeStamp Delivery (i.e. assume significant bandwidth)
m_ulRuleBw[i] = 0;
m_bRuleTimeStampDelivery[i] = TRUE;
}
pBuffer->Release();
}
else
{
/* XXXSMP Temporary hack for invalid rulebooks */
if (i == 0)
{
IHXValues* pHeader = 0;
HX_VERIFY(pHeader = pStream->GetHeader());
pHeader->GetPropertyULONG32("AvgBitRate",m_ulRuleBw[i]);
pHeader->Release();
}
else
{
m_ulRuleBw[i] = 0;
}
}
pValues->Release();
m_pSubInfo[i] = 0;
m_pRuleSubscribeStatus[i] = FALSE;
}
HXBOOL bFixed = TRUE;
m_bHasExpression = m_pRuleBook->HasExpression();
if (m_bHasExpression == FALSE)
{
UINT16 i;
for (i = 0; i < m_nNumRules; i++)
{
if (m_bRuleTimeStampDelivery[i] == FALSE)
{
bFixed = FALSE;
break;
}
}
if (bFixed)
{
m_ulFixedBandwidth = 1;
}
else
{
m_ulCurrentBandwidth = 0;
for (i = 0; i < m_nNumRules; i++)
{
m_ulCurrentBandwidth += m_ulRuleBw[i];
}
m_ulFixedBandwidth = m_ulCurrentBandwidth;
}
}
}
else
{
IHXValues* pHeader = 0;
HX_VERIFY(pHeader = pStream->GetHeader());
HX_VERIFY(HXR_OK == pHeader->GetPropertyULONG32("AvgBitRate",
m_ulFixedBandwidth));
m_ulCurrentBandwidth = m_ulFixedBandwidth;
pHeader->Release();
}
/* Get Registry ID's for interesting properties */
IHXBuffer* pPropName = 0;
// init.
memset(m_szRecv, 0, MAX_DISPLAY_NAME);
memset(m_szLost, 0, MAX_DISPLAY_NAME);
memset(m_szClipBandwidth, 0, MAX_DISPLAY_NAME);
if( m_pRegistry )
{
m_pRegistry->GetPropName(ulStreamID, pPropName);
}
if (pPropName)
{
SafeSprintf(m_szRecv, MAX_DISPLAY_NAME, "%s.received", pPropName->GetBuffer());
m_ulIDRecv = m_pRegistry->GetId(m_szRecv);
SafeSprintf(m_szLost, MAX_DISPLAY_NAME, "%s.lost", pPropName->GetBuffer());
m_ulIDLost = m_pRegistry->GetId(m_szLost);
SafeSprintf(m_szClipBandwidth, MAX_DISPLAY_NAME, "%s.ClipBandwidth", pPropName->GetBuffer());
m_ulIDClipBandwidth = m_pRegistry->GetId(m_szClipBandwidth);
pPropName->Release();
}
/*
* We consider Local source as a Network source IFF someone uses core
* for simulated network playback (used for Preview mode in the Encoder)
*/
if (pSource->IsLocalSource() && !pSource->IsSimulatedNetworkPlayback())
{
/* Some large bandwidth */
m_ulBandwidthAllocation = 0x7FFFFFFF;
HXBOOL b;
SetBandwidthUsage(m_ulBandwidthAllocation, b);
}
else if (pSource->IsPNAProtocol())
{
IHXBuffer* pMimeType = NULL;
m_pHeader->GetPropertyCString("MimeTYpe", pMimeType);
if (pMimeType &&
::strcasecmp((const char*) pMimeType->GetBuffer(), "audio/x-pn-realaudio") == 0)
{
/* Some large bandwidth */
m_ulBandwidthAllocation = 0x7FFFFFFF;
HXBOOL b;
SetBandwidthUsage(m_ulBandwidthAllocation, b);
}
HX_RELEASE(pMimeType);
}
else if (pRuleBook)
{
m_pLossCB = new LossCheckCallback(this);
m_pLossCB->AddRef();
m_ulLossCBHandle = m_pScheduler->RelativeEnter(m_pLossCB, 1000);
}
HX_RELEASE(pRuleBook);
}
void
QueueFileSize(CBigByteGrowingQueue* pQ, UINT32 ulFileSize)
{
char buf[14]; /* Flawfinder: ignore */
if ( ulFileSize )
{
pQ->EnQueue(z_pFileSize);
UINT32 num;
HXBOOL first = TRUE;
// billions.
num = (ulFileSize / 1000000000);
if ( num )
{
SafeSprintf(buf, sizeof(buf), "%u", num);
pQ->EnQueue(buf);
pQ->EnQueue(",");
first = FALSE;
}
ulFileSize %= 1000000000;
// millions
num = (ulFileSize / 1000000);
if ( (num) || !first )
{
if ( first )
{
SafeSprintf(buf, sizeof(buf), "%u", num);
first = FALSE;
}
else
{
SafeSprintf(buf, sizeof(buf), "%03u", num);
}
pQ->EnQueue(buf);
pQ->EnQueue(",");
}
ulFileSize %= 1000000;
// thousands
num = (ulFileSize / 1000);
if ( (num) || !first )
{
if ( first )
{
SafeSprintf(buf, sizeof(buf), "%u", num);
first = FALSE;
}
else
{
SafeSprintf(buf, sizeof(buf), "%03u", num);
}
pQ->EnQueue(buf);
pQ->EnQueue(",");
}
// whats left...
ulFileSize %= 1000;
if ( first )
{
SafeSprintf(buf, sizeof(buf), "%u", ulFileSize);
first = FALSE;
}
else
{
SafeSprintf(buf, sizeof(buf), "%03u", ulFileSize);
}
pQ->EnQueue(buf);
pQ->EnQueue(" Bytes");
pQ->EnQueue(z_pEndLine);
}
}
