int CConsolePromissions::Check_Split_User(const char* pUser, const char* pUserList)
{
char szTempUser[MAX_BUFF_50] = { '\0' };
char* pPromissPosBegin = (char* )pUserList;
char* pPromissPos = ACE_OS::strstr((char* )pPromissPosBegin, ",");
while (NULL != pPromissPos)
{
uint32 u4NameLen = (uint32)(pPromissPos - pPromissPosBegin);
if (u4NameLen > MAX_BUFF_50)
{
pPromissPosBegin = pPromissPos + 1;
pPromissPos = ACE_OS::strstr((char*)pUserList, ",");
continue;
}
if (true == memcpy_safe(pPromissPosBegin, u4NameLen, szTempUser, u4NameLen))
{
szTempUser[u4NameLen] = '\0';
}
if (0 == ACE_OS::strcmp(szTempUser, pUser))
{
return 0;
}
pPromissPosBegin = pPromissPos + 1;
pPromissPos = ACE_OS::strstr((char*)pPromissPosBegin, ",");
}
//判断最后一个User
if ((uint32)(pPromissPosBegin - pUserList) < (uint32)ACE_OS::strlen(pUserList))
{
uint32 u4NameLen = 0;
if (pUserList == pPromissPosBegin)
{
//只有一个
u4NameLen = (uint32)ACE_OS::strlen(pUserList);
memcpy_safe(pPromissPosBegin, u4NameLen, szTempUser, u4NameLen);
szTempUser[u4NameLen] = '\0';
}
else
{
//最后一个
u4NameLen = (uint32)strlen(pUserList) - (uint32)(pPromissPosBegin - pUserList - 1);
memcpy_safe(pPromissPosBegin, u4NameLen, szTempUser, u4NameLen);
szTempUser[u4NameLen] = '\0';
}
if (0 == ACE_OS::strcmp(szTempUser, pUser))
{
return 0;
}
}
OUR_DEBUG((LM_INFO, "[CConsolePromissions::Check_Promission][%s]user is no promission.\n", pUser));
return -2;
}
int memset_safe ( void *_dest, int c, uint32_t len )
{
uint8_t *dest = (uint8_t *)_dest;
uint8_t buf[4096];
memset( buf, c, (len > 4096) ? 4096 : len );
for ( ;; )
{
if ( len > 4096 )
{
if ( !memcpy_safe(dest, buf, 4096) )
return 0;
dest += 4096;
len -= 4096;
}
else
{
if ( !memcpy_safe(dest, buf, len) )
return 0;
break;
}
}
return 1;
}
int memcmp_safe ( const void *_s1, const void *_s2, uint32_t len )
{
const uint8_t *s1 = (const uint8_t *)_s1;
const uint8_t *s2 = (const uint8_t *)_s2;
uint8_t buf[4096];
for ( ;; )
{
if ( len > 4096 )
{
if ( !memcpy_safe(buf, s1, 4096) )
return 0;
if ( memcmp(buf, s2, 4096) )
return 0;
s1 += 4096;
s2 += 4096;
len -= 4096;
}
else
{
if ( !memcpy_safe(buf, s1, len) )
return 0;
if ( memcmp(buf, s2, len) )
return 0;
break;
}
}
return 1;
}
bool CPacketParse::SetPacketHead(uint32 u4ConnectID, ACE_Message_Block* pmbHead, IMessageBlockManager* pMessageBlockManager)
{
//这里添加自己对包头的分析，主要分析出包长度。
//获得包头30个字节的相关信息，还原成数据包信息结构
char* pData = (char* )pmbHead->rd_ptr();
uint32 u4Len = pmbHead->length();
uint32 u4Pos = 0;
m_u4HeadSrcSize = PACKET_HEAD_LENGTH;
memcpy_safe((char* )&pData[u4Pos], (uint32)sizeof(uint16), (char* )&m_objPacketHeadInfo.m_u2Version, (uint32)sizeof(uint16));
Check_Recv_Unit16(m_objPacketHeadInfo.m_u2Version);
u4Pos += sizeof(uint16);
memcpy_safe((char* )&pData[u4Pos], (uint32)sizeof(uint16), (char* )&m_objPacketHeadInfo.m_u2CmdID, (uint32)sizeof(uint16));
Check_Recv_Unit16(m_objPacketHeadInfo.m_u2CmdID);
u4Pos += sizeof(uint16);
memcpy_safe((char* )&pData[u4Pos], (uint32)sizeof(uint32), (char* )&m_objPacketHeadInfo.m_u4BodyLen, (uint32)sizeof(uint32));
Check_Recv_Unit32(m_objPacketHeadInfo.m_u4BodyLen);
u4Pos += sizeof(uint32);
memcpy_safe((char* )&pData[u4Pos], (uint32)(sizeof(char)*32), (char* )&m_objPacketHeadInfo.m_szSession, (uint32)(sizeof(char)*32));
u4Pos += sizeof(char)*32;
m_u4PacketData = m_objPacketHeadInfo.m_u4BodyLen;
m_u2PacketCommandID = m_objPacketHeadInfo.m_u2CmdID;
m_pmbHead = pmbHead;
return true;
}
void decl_replace_with(decl *to, decl *from)
{
/* XXX: memleak of .ref */
memcpy_safe(&to->where, &from->where);
to->ref = from->ref;
to->attr = RETAIN(from->attr);
to->spel_asm = from->spel_asm;
/* no point copying bitfield stuff */
memcpy_safe(&to->bits, &from->bits);
}
void decl_replace_with(decl *to, decl *from)
{
attribute **i;
/* XXX: memleak of .ref */
memcpy_safe(&to->where, &from->where);
to->ref = from->ref;
to->spel_asm = from->spel_asm, from->spel_asm = NULL;
/* no point copying bitfield stuff */
memcpy_safe(&to->bits, &from->bits);
for(i = from->attr; i && *i; i++)
dynarray_add(&to->attr, RETAIN(*i));
}
bool CPacketParse::MakePacket(uint32 u4ConnectID, const char* pData, uint32 u4Len, ACE_Message_Block* pMbData, uint16 u2CommandID)
{
if(pMbData == NULL && u2CommandID == 0)
{
return false;
}
//拼装数据包
memcpy_safe((char* )&u4Len, (uint32)sizeof(uint32), (char* )pMbData->wr_ptr(), (uint32)sizeof(uint32));
pMbData->wr_ptr(sizeof(uint32));
memcpy_safe((char* )pData, u4Len, pMbData->wr_ptr(), u4Len);
pMbData->wr_ptr(u4Len);
return true;
}
void expr_mutate_str(
expr *e,
char *s, size_t len,
int wide,
where *w, symtable *stab)
{
expr_mutate_wrapper(e, str);
e->bits.strlit.lit_at.lit = strings_lookup(
&symtab_global(stab)->literals,
s, len, wide);
memcpy_safe(&e->bits.strlit.lit_at.where, w);
memcpy_safe(&e->where, w);
}
void fold_stmt_label(stmt *s)
{
label *l = symtab_label_find_or_new(
s->symtab, s->bits.lbl.spel, &s->where);
/* update its where */
memcpy_safe(&l->where, &s->where);
/* update its scope */
l->scope = s->symtab;
/* update code the label uses */
l->next_stmt = s;
if(l->complete){
warn_at_print_error(&s->where, "duplicate label '%s'", s->bits.lbl.spel);
fold_had_error = 1;
}else{
l->complete = 1;
}
s->bits.lbl.label = l;
l->unused = s->bits.lbl.unused;
fold_stmt(s->lhs); /* compound */
}
void token_get_current_str(
char **ps, size_t *pl, int *pwide, where *w)
{
extern char *currentstring;
extern size_t currentstringlen;
extern int currentstringwide;
*ps = currentstring;
if(pwide)
*pwide = currentstringwide;
else if(currentstringwide)
die_at(NULL, "wide string not wanted");
if(w){
extern where currentstringwhere;
memcpy_safe(w, ¤tstringwhere);
}
if(pl){
*pl = currentstringlen;
}else{
char *p = memchr(currentstring, '\0', currentstringlen);
if(p && p < currentstring + currentstringlen - 1)
cc1_warn_at(NULL, str_contain_nul,
"nul-character terminates string early (%s)", p + 1);
}
currentstring = NULL;
currentstringlen = 0;
}
void CLSServerManager::Recv_LS_Key_Update(const char* pRecvBuff, uint32 u4Len)
{
uint32 u4LGID = 0;
char szListKey[33] = {'\0'};
memcpy_safe((char* )&pRecvBuff[40], sizeof(uint32), (char* )&u4LGID, sizeof(uint32));
if(m_u4LGID == u4LGID)
{
//更新LSKEY
uint8 u1Len = 0;
memcpy_safe((char* )&pRecvBuff[44], 1, (char* )&u1Len, 1);
memcpy_safe((char* )&pRecvBuff[45], u1Len, szListKey, u1Len);
OUR_DEBUG((LM_INFO, "[CLSServerManager::Recv_LS_Key_Update]m_szLSKey=%s.\n", szListKey));
}
}
int patcher_remove ( struct patch_set *patch )
{
int i;
if ( patch->failed )
{
patch->failed = 0;
return 1;
}
if ( patch->installed )
{
for ( i = 0; i < PATCHER_CHUNKS_MAX; i++ )
{
if ( patch->chunk[i].ptr == NULL )
break;
if ( !memcpy_safe((uint8_t *)patch->chunk[i].ptr, patch->chunk[i].data_orig, patch->chunk[i].len) )
{} //Log( "Failed to restore patch '%s' chunk %d", patch->name, i );
}
patch->installed = 0;
//Log("Removed patch '%s'.", patch->name);
}
return 1;
}
bool CLSServerManager::RecvData(ACE_Message_Block* mbRecv, _ClientIPInfo objServerIPInfo)
{
//处理收到来自LS的数据
if(mbRecv->length() <= 40)
{
//接收到了不完整的包头，丢弃
return true;
}
char* pRecvBuffer = mbRecv->rd_ptr();
//从包头中解析出命令字ID
uint16 u2CommandID = 0;
memcpy_safe(&pRecvBuffer[2], sizeof(uint16), (char* )&u2CommandID, sizeof(uint16));
if(u2CommandID == COMMAND_LOGIC_LG_LOGIN_R)
{
Recv_LS_Login(pRecvBuffer, (uint32)mbRecv->length());
}
else if(u2CommandID == COMMAND_LOGIC_LG_KEY_R)
{
Recv_LS_Key_Update(pRecvBuffer, (uint32)mbRecv->length());
}
else if(u2CommandID == COMMAND_LOGIC_LG_LIST_R)
{
Recv_LS_List_Update(pRecvBuffer, (uint32)mbRecv->length());
}
return true;
}
bool CServerParse::MakePacket(const char* pData, uint32 u4Len, ACE_Message_Block* pMbData)
{
if(pMbData == NULL)
{
return false;
}
//拼装数据包
memcpy_safe((char* )&u4Len, (uint32)sizeof(uint32), pMbData->wr_ptr(), (uint32)sizeof(uint32));
pMbData->wr_ptr(sizeof(uint32));
//NOTICE，这里的pMbData可能会有内存溢出，这里需要完善一下
memcpy_safe((char* )pData, u4Len, pMbData->wr_ptr(), u4Len);
pMbData->wr_ptr(u4Len);
return true;
}
static void ctp_fg_restore_config_data(const char *name, void *data, int len)
{
struct max17042_config_data *fg_cfg_data =
(struct max17042_config_data *)data;
int ret = 0;
fg_cfg_data->cfg = 0x2210;
fg_cfg_data->learn_cfg = 0x0076;
fg_cfg_data->filter_cfg = 0x87a4;
fg_cfg_data->relax_cfg = 0x506b;
ret = memcpy_safe(&fg_cfg_data->cell_char_tbl,
sizeof(fg_cfg_data->cell_char_tbl),
ctp_cell_char_tbl,
sizeof(ctp_cell_char_tbl));
if (ret) {
pr_err("%s, err:%d in copying cell char tbl\n",
__func__, ret);
return ret;
}
fg_cfg_data->rcomp0 = 0x0047;
fg_cfg_data->tempCo = 0x1920;
fg_cfg_data->etc = 0x00e0;
fg_cfg_data->kempty0 = 0x0100;
fg_cfg_data->ichgt_term = 0x0240;
fg_cfg_data->full_cap = 3408;
fg_cfg_data->design_cap = 3408;
fg_cfg_data->full_capnom = 3408;
fg_cfg_data->soc_empty = 0x0060;
fg_cfg_data->rsense = 1;
fg_cfg_data->cycles = 0x160;
}
static int option_append(uint8_t options[], size_t size, size_t *offset,
uint8_t code, size_t optlen, const void *optval) {
assert(options);
assert(offset);
if (code != SD_DHCP_OPTION_END)
/* always make sure there is space for an END option */
size--;
switch (code) {
case SD_DHCP_OPTION_PAD:
case SD_DHCP_OPTION_END:
if (size < *offset + 1)
return -ENOBUFS;
options[*offset] = code;
*offset += 1;
break;
default:
if (size < *offset + optlen + 2)
return -ENOBUFS;
options[*offset] = code;
options[*offset + 1] = optlen;
memcpy_safe(&options[*offset + 2], optval, optlen);
*offset += optlen + 2;
break;
}
return 0;
}
bool CConsolePacketParse::SetPacketHead(uint32 u4ConnectID, ACE_Message_Block* pmbHead, IMessageBlockManager* pMessageBlockManager)
{
char* pData = pmbHead->rd_ptr();
if(u4ConnectID == 0 && pMessageBlockManager != NULL)
{
//UDP数据包，没有u4ConnectID
}
//这里添加自己对包头的分析，主要分析出包长度。
uint32 u4Len = pmbHead->length();
m_u4HeadSrcSize = u4Len;
if(u4Len == sizeof(uint32))
{
memcpy_safe((char* )pData, (uint32)sizeof(uint32), (char* )&m_u4PacketData, (uint32)sizeof(uint32));
m_pmbHead = pmbHead;
m_blIsHead = true;
return true;
}
else
{
return false;
}
}
static void check_implicit_funcall(expr *e, symtable *stab, char **const psp)
{
struct symtab_entry ent;
funcargs *args;
decl *df, *owning_func;
type *func_ty;
if(e->expr->in_parens
|| !expr_kind(e->expr, identifier)
/* not folded yet, hence no 'e->expr->bits.ident.type != IDENT_NORM' */
/* get the spel that parse stashes in the identifier expr: */
|| !((*psp) = e->expr->bits.ident.bits.ident.spel))
{
return;
}
/* check for implicit function */
if(symtab_search(stab, *psp, NULL, &ent)
&& ent.type == SYMTAB_ENT_DECL)
{
e->expr->bits.ident.bits.ident.sym = ent.bits.decl->sym;
return;
}
args = funcargs_new();
/* set up the funcargs as if it's "x()" - i.e. any args */
funcargs_empty(args);
func_ty = type_func_of(
type_nav_btype(cc1_type_nav, type_int),
args,
symtab_new(stab, &e->where) /*new symtable for args*/);
cc1_warn_at(&e->expr->where, implicit_func,
"implicit declaration of function \"%s\"", *psp);
df = decl_new();
memcpy_safe(&df->where, &e->where);
df->ref = func_ty;
df->spel = e->expr->bits.ident.bits.ident.spel;
df->flags |= DECL_FLAGS_IMPLICIT;
fold_decl(df, stab); /* update calling conv, for e.g. */
df->sym->type = sym_global;
e->expr->bits.ident.bits.ident.sym = df->sym;
e->expr->tree_type = func_ty;
owning_func = symtab_func(stab);
if(owning_func)
symtab_insert_before(symtab_root(stab), owning_func, df);
else
symtab_add_to_scope(symtab_root(stab), df); /* function call at global scope */
}
void CLSServerManager::Recv_LS_List_Update(const char* pRecvBuff, uint32 u4Len)
{
m_objlistManager.Clear();
//获得当前的MD5Key值
uint32 u4Pos = 40;
uint8 u1KeyLen = pRecvBuff[u4Pos];
u4Pos++;
char szMD5[33] = {'\0'};
memcpy_safe((char* )&pRecvBuff[u4Pos], u1KeyLen, szMD5, u1KeyLen);
u4Pos += (uint32)u1KeyLen;
m_objlistManager.Set_MD5_Data(szMD5);
//得到列表的长度
uint32 u4Count = 0;
memcpy_safe((char* )&pRecvBuff[u4Pos], (uint32)sizeof(uint32), (char* )&u4Count, (uint32)sizeof(uint32));
u4Pos += (uint32)sizeof(uint32);
uint32 u4LGID = 0;
char szLGIP[50] = {'\0'};
uint32 u4LGPort = 0;
_VCHARS_STR strIP;
for(uint32 i = 0; i < u4Count; i++)
{
memcpy_safe((char* )&pRecvBuff[u4Pos], (uint32)sizeof(uint32), (char* )&u4LGID, (uint32)sizeof(uint32));
u4Pos += (uint32)sizeof(uint32);
uint8 u1IPLen = pRecvBuff[u4Pos];
u4Pos++;
memcpy_safe((char* )&pRecvBuff[u4Pos], u1IPLen, szLGIP, u1IPLen);
u4Pos += (uint32)u1IPLen;
memcpy_safe((char* )&pRecvBuff[u4Pos], (uint32)sizeof(uint32), (char* )&u4LGPort, (uint32)sizeof(uint32));
u4Pos += (uint32)sizeof(uint32);
m_objlistManager.Add_LG_Info(0, u4LGID, szLGIP, u4LGPort);
}
//存储为本地文件
m_objlistManager.SaveList();
}
int Make_Common_Dispose_Client_WorkTread_Message(uint16 u2CommandID, uint32 u4ServerID, ACE_Message_Block* pmblk, ACE_INET_Addr& AddrRemote)
{
//组织数据
CMessage* pMessage = App_MessageServiceGroup::instance()->CreateMessage(u4ServerID, CONNECT_IO_TCP);
if (NULL == pMessage)
{
//放入消息框架失败
OUR_DEBUG((LM_ERROR, "[CConnectClient::SendMessageGroup] ConnectID = %d CreateMessage fail.\n", u4ServerID));
App_MessageBlockManager::instance()->Close(pmblk);
return -1;
}
else
{
ACE_Message_Block* pMBBHead = App_MessageBlockManager::instance()->Create(sizeof(uint32));
if (NULL == pMBBHead)
{
OUR_DEBUG((LM_ERROR, "[CConnectClient::SendMessageGroup] ConnectID = %d pMBBHead fail.\n", u4ServerID));
App_MessageBlockManager::instance()->Close(pmblk);
return -1;
}
//添加消息包头
uint32 u4PacketLen = (uint32)pmblk->length();
memcpy_safe((char*)&u4PacketLen, sizeof(uint32), pMBBHead->wr_ptr(), sizeof(uint32));
pMBBHead->wr_ptr(sizeof(uint32));
sprintf_safe(pMessage->GetMessageBase()->m_szListenIP, MAX_BUFF_20, "%s", AddrRemote.get_host_addr());
sprintf_safe(pMessage->GetMessageBase()->m_szIP, MAX_BUFF_20, "127.0.0.1");
pMessage->GetMessageBase()->m_u2Cmd = u2CommandID;
pMessage->GetMessageBase()->m_u4ConnectID = u4ServerID;
pMessage->GetMessageBase()->m_u4ListenPort = (uint32)AddrRemote.get_port_number();
pMessage->GetMessageBase()->m_tvRecvTime = ACE_OS::gettimeofday();
pMessage->GetMessageBase()->m_u1ResouceType = RESOUCE_FROM_SERVER;
pMessage->GetMessageBase()->m_u4HeadSrcSize = sizeof(uint32);
pMessage->GetMessageBase()->m_u4BodySrcSize = u4PacketLen;
pMessage->SetPacketHead(pMBBHead);
pMessage->SetPacketBody(pmblk);
//将要处理的消息放入消息处理线程
if (false == App_MessageServiceGroup::instance()->PutMessage(pMessage))
{
OUR_DEBUG((LM_ERROR, "[CConnectClient::SendMessageGroup] App_MessageServiceGroup::instance()->PutMessage Error.\n"));
App_MessageServiceGroup::instance()->DeleteMessage(u4ServerID, pMessage);
return -1;
}
}
return 0;
}
bool CServerParse::SetPacketHead(char* pData, uint32 u4Len)
{
//这里添加自己对包头的分析，主要分析出包长度。
if(u4Len == sizeof(uint32))
{
memcpy_safe(pData, (uint32)sizeof(uint32), (char* )&m_u4PacketData, (uint32)sizeof(uint32));
m_blIsHead = true;
return true;
}
else
{
return false;
}
}
VOID GTAfunc_SetMoveSpeed ( object_base *entity, CVector vecMoveSpeed )
{
DWORD dwFunc = FUNC_GetMoveSpeed;
DWORD dwThis = ( DWORD ) entity;
DWORD dwReturn = 0;
__asm
{
mov ecx, dwThis
call dwFunc
mov dwReturn, eax
}
memcpy_safe( (void *)dwReturn, &vecMoveSpeed, sizeof(CVector) );
}
bool CServerParse::SetPacketBody(char* pData, uint32 u4Len)
{
//这里分析出包体内的一些数据，如果包头包含了CommandID，那么包体就不必做解析。
if(u4Len >= sizeof(uint16))
{
memcpy_safe(pData, (uint32)sizeof(uint16), (char* )&m_u2PacketCommandID, (uint32)sizeof(uint16));
m_blIsHead = false;
return true;
}
else
{
m_blIsHead = false;
return false;
}
}
CVector GTAfunc_GetMoveSpeed ( object_base *entity )
{
CVector vecMoveSpeed;
DWORD dwFunc = FUNC_GetMoveSpeed;
DWORD dwThis = ( DWORD ) entity;
DWORD dwReturn = 0;
__asm
{
mov ecx, dwThis
call dwFunc
mov dwReturn, eax
}
memcpy_safe( &vecMoveSpeed, (void *)dwReturn, sizeof(CVector) );
return vecMoveSpeed;
}
bool CClientReConnectManager::SendData(int nServerID, char*& pData, int nSize, bool blIsDelete)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_ThreadWritrLock);
//查找已有连接
char szServerID[10] = {'\0'};
sprintf_safe(szServerID, 10, "%d", nServerID);
CReactorClientInfo* pClientInfo = m_objClientTCPList.Get_Hash_Box_Data(szServerID);
if (NULL == pClientInfo)
{
//如果这个链接已经存在，则不创建新的链接
OUR_DEBUG((LM_ERROR, "[CProConnectManager::SendData]nServerID =(%d) is not exist.\n", nServerID));
if (true == blIsDelete)
{
SAFE_DELETE_ARRAY(pData);
}
return false;
}
ACE_Message_Block* pmblk = App_MessageBlockManager::instance()->Create(nSize);
if (NULL == pmblk)
{
OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::SendData]nServerID =(%d) pmblk is NULL.\n", nServerID));
if (true == blIsDelete)
{
SAFE_DELETE_ARRAY(pData);
}
return false;
}
memcpy_safe((char* )pData, (uint32)nSize, pmblk->wr_ptr(), (uint32)nSize);
pmblk->wr_ptr(nSize);
if (true == blIsDelete)
{
SAFE_DELETE_ARRAY(pData);
}
//发送数据
return pClientInfo->SendData(pmblk);
}
static void fold_const_expr_if(expr *e, consty *k)
{
consty consts[3];
int res;
const_fold(e->expr, &consts[0]);
const_fold(e->rhs, &consts[2]);
if(e->lhs)
const_fold(e->lhs, &consts[1]);
else
consts[1] = consts[0];
/* only evaluate lhs/rhs' constness if we need to */
if(!CONST_AT_COMPILE_TIME(consts[0].type)){
k->type = CONST_NO;
return;
}
switch(consts[0].type){
case CONST_NUM:
{
numeric *n = &consts[0].bits.num;
res = n->suffix & VAL_FLOATING ? n->val.f : n->val.i;
break;
}
case CONST_ADDR:
case CONST_STRK:
res = 1;
break;
case CONST_NEED_ADDR:
case CONST_NO:
ICE("buh");
}
res = res ? 1 : 2; /* index into consts */
if(!CONST_AT_COMPILE_TIME(consts[res].type)){
k->type = CONST_NO;
}else{
memcpy_safe(k, &consts[res]);
k->nonstandard_const = consts[res == 1 ? 2 : 1].nonstandard_const;
}
}
bool CClientReConnectManager::SendData(int nServerID, const char* pData, int nSize, bool blIsDelete)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_ThreadWritrLock);
mapReactorConnectInfo::iterator f = m_mapConnectInfo.find(nServerID);
if (f == m_mapConnectInfo.end())
{
//如果这个链接已经存在，则不创建新的链接
OUR_DEBUG((LM_ERROR, "[CProConnectManager::SendData]nServerID =(%d) is not exist.\n", nServerID));
if (true == blIsDelete)
{
SAFE_DELETE_ARRAY(pData);
}
return false;
}
CReactorClientInfo* pClientInfo = (CReactorClientInfo*)f->second;
ACE_Message_Block* pmblk = App_MessageBlockManager::instance()->Create(nSize);
if (NULL == pmblk)
{
OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::SendData]nServerID =(%d) pmblk is NULL.\n", nServerID));
if (true == blIsDelete)
{
SAFE_DELETE_ARRAY(pData);
}
return false;
}
memcpy_safe((char* )pData, (uint32)nSize, pmblk->wr_ptr(), (uint32)nSize);
pmblk->wr_ptr(nSize);
if (true == blIsDelete)
{
SAFE_DELETE_ARRAY(pData);
}
//发送数据
return pClientInfo->SendData(pmblk);
}
bool CPacketParse::SetPacketBody(uint32 u4ConnectID, ACE_Message_Block* pmbBody, IMessageBlockManager* pMessageBlockManager)
{
//这里分析出包体内的一些数据，如果包头包含了CommandID，那么包体就不必做解析。
char* pData = (char* )pmbBody->rd_ptr();
uint32 u4Len = pmbBody->length();
m_u4BodySrcSize = u4Len;
if(u4Len >= sizeof(uint16))
{
memcpy_safe(pData, (uint32)sizeof(uint16), (char* )&m_u2PacketCommandID, (uint32)sizeof(uint16));
m_blIsHead = false;
m_pmbBody = pmbBody;
return true;
}
else
{
m_blIsHead = false;
return false;
}
}
void ClistManager::Compare_MD5()
{
//CMD5 objMD5;
//objMD5.ENCODE_DATA((char* )&m_vecLGInfo, sizeof(m_vecLGInfo), m_szMD5);
unsigned char uszMD5[16] = {'\0'};
MD5_CTX obj_MD5_CTX;
MD5Init(&obj_MD5_CTX);
MD5Update(&obj_MD5_CTX, (unsigned char* )&m_vecLGInfo, sizeof(m_vecLGInfo));
MD5Final(&obj_MD5_CTX, uszMD5);
//将数组转换为字符串
char szDigit[3] = {'\0'};
for(int i = 0; i < 16; i++)
{
sprintf_safe(szDigit, 3, "%02x", (char)uszMD5[i]);
memcpy_safe((char* )&uszMD5[i*2], 32 - i*2, szDigit, 2);
}
}
static bool msic_battery_check(struct max17042_platform_data *pdata)
{
struct sfi_table_simple *sb;
char *mrfl_batt_str = "INTN0001";
#ifdef CONFIG_SFI
sb = (struct sfi_table_simple *)get_oem0_table();
#else
sb = NULL;
#endif
if (sb == NULL) {
pr_info("invalid battery detected\n");
snprintf(pdata->battid, BATTID_LEN + 1, "UNKNOWNB");
snprintf(pdata->serial_num, SERIAL_NUM_LEN + 1, "000000");
return false;
} else {
pr_info("valid battery detected\n");
/* First entry in OEM0 table is the BATTID. Read battid
* if pentry is not NULL and header length is greater
* than BATTID length*/
if (sb->pentry && sb->header.len >= BATTID_LEN) {
if (!((INTEL_MID_BOARD(1, TABLET, MRFL)) ||
(INTEL_MID_BOARD(1, PHONE, MRFL)) ||
(INTEL_MID_BOARD(1, PHONE, MOFD)) ||
(INTEL_MID_BOARD(1, TABLET, MOFD)))) {
snprintf(pdata->battid, BATTID_LEN + 1, "%s",
(char *)sb->pentry);
} else {
if (strncmp((char *)sb->pentry,
"PG000001", (BATTID_LEN)) == 0) {
snprintf(pdata->battid,
(BATTID_LEN + 1),
"%s", mrfl_batt_str);
} else {
snprintf(pdata->battid,
(BATTID_LEN + 1),
"%s", (char *)sb->pentry);
}
}
/* First 2 bytes represent the model name
* and the remaining 6 bytes represent the
* serial number. */
if (pdata->battid[0] == 'I' &&
pdata->battid[1] >= '0'
&& pdata->battid[1] <= '9') {
unsigned char tmp[SERIAL_NUM_LEN + 2];
int i, ret = 0;
snprintf(pdata->model_name,
(MODEL_NAME_LEN) + 1,
"%s", pdata->battid);
ret = memcpy_safe(tmp, BATTID_LEN, sb->pentry,
BATTID_LEN);
if (ret) {
pr_err("%s, err:%d copying BATTID\n",
__func__, ret);
return false;
}
for (i = 0; i < SERIAL_NUM_LEN; i++) {
snprintf(pdata->serial_num + i*2,
sizeof(pdata->serial_num) - i*2,
"%02x", tmp[i + MODEL_NAME_LEN]);
}
if ((2 * SERIAL_NUM_LEN) <
ARRAY_SIZE(pdata->serial_num))
pdata->serial_num[2 * SERIAL_NUM_LEN]
= '\0';
} else {
snprintf(pdata->model_name,
(MODEL_NAME_LEN + 1),
"%s", pdata->battid);
snprintf(pdata->serial_num,
(SERIAL_NUM_LEN + 1), "%s",
pdata->battid + MODEL_NAME_LEN);
}
}
return true;
}
return false;
}
