void CIPGRegUpdCmd::Execute()
{
NLOG_INFO("[IPGRegUpdCmd]: received msg = %s", MsgToStr(m_rMsg).c_str());
CMgmtPOption::OptionIPGatewayInfoData *pOpData1 = NULL;
std::list<CMgmtPOption::OptionIPRoutesListData> rawRouteInfo;
CMgmtPOption::OptionKeepAliveIntervalData *pOpData2 = NULL;
if (!ProcessMsg(&pOpData1, rawRouteInfo, &pOpData2))
{
if (m_rIPGList.find(CIPGInfo (m_rMsg.m_oNetAddr)) == m_rIPGList.end())
NLOG_ERR("[IPGRegUpdCmd]: MODULE=%s was not added in CACHE because of invalid register/update INFO ", AddrToStr(m_rMsg.m_oNetAddr).c_str());
return;
}
///add module if it doesn't exist
CIPGInfo key(m_rMsg.m_oNetAddr);
std::set<CIPGInfo>::iterator i = m_rIPGList.find(key);
bool isNewIPG = false;
if (i == m_rIPGList.end())
{
///FIRST
CTunnelKey info(pOpData1->m_IPGAddrIPv4, pOpData1->m_szIPGAddrIPv6, 128);
if (m_rFARAndIPGPubInf.insert(info).second == false)
{
NLOG_WARN("[IPGRegUpdCmd]: MODULE=%s was not added in CACHE because of duplicated publicInfo=%s, "
"skip processing msg = %s", AddrToStr(m_rMsg.m_oNetAddr).c_str(),
TunnelKeyToStr(info).c_str(), MsgToStr(m_rMsg).c_str());
return;
}
isNewIPG = true;
i = m_rIPGList.insert(CIPGInfo(m_rMsg.m_oNetAddr, CModuleInfo::MT_REGISTERED)).first;
i->SetPendingTimedout(m_rApp.GetConfig().m_nPendingRelationTimedoutS);
}
CIPGInfo *pIPGInfo = (CIPGInfo*)&(*i);
pIPGInfo->SetTimedOut(CModuleInfo::MTT_KEEP_ALIVE, pOpData2->m_IntSec, pOpData2->m_IntUSec);
pIPGInfo->SetPublicIpgInfo(*pOpData1);
if(pIPGInfo->GetState() != CModuleInfo::MT_REGISTERED)
pIPGInfo->SetState(CModuleInfo::MT_REGISTERED);
///process
std::list<CMgmtPOption::OptionIPRoutesListData> IPGAddedRoute;
std::list<CMgmtPOption::OptionIPRoutesListData> IPGEraseRoute;
ProcessRegIPG(i, isNewIPG, rawRouteInfo, IPGAddedRoute, IPGEraseRoute);
NLOG_INFO("[IPGRegUpdCmd]: raw(routes=%d), add(routes=%d), erase(routes=%d)", rawRouteInfo.size(), IPGAddedRoute.size(), IPGEraseRoute.size());
///send result
if (IPGAddedRoute.size() > 0)
//SendAddTunnOnIPG(m_rMsg.m_oNetAddr, IPGAddedTun); -- not add only the difference but all
SendSetTunnOnIPG(i);
if (IPGEraseRoute.size() > 0)
SendDelTunnOnIPG(m_rMsg.m_oNetAddr, IPGEraseRoute, m_rApp);
}
int SendMsg(int message, int Param1, int param2, void *object)
{
TMsg msg;
msg.Object=object;
msg.Message=message;
msg.Param1=Param1;
msg.Param2=param2;
return ProcessMsg(&msg);
}
int CRoleDBThread::Run()
{
int iRet = 0;
int iCodeLen = 0;
SHandleResult stMsgHandleResult;
while (true)
{
//process all msg
while (true)
{
iRet = ReceiveMsg(iCodeLen);
//receive one msg
if (0 == iRet)
{
iRet = m_stProtocolEngine.Decode((unsigned char*)m_szCodeBuf, iCodeLen, &m_stGameMsg);
//decode success
if (0 == iRet)
{
DEBUG_THREAD(m_iThreadIdx, "Receive code OK, Uin = %u, Msg = %d\n",
m_stGameMsg.m_stmsghead().m_uin(),
m_stGameMsg.m_stmsghead().m_uimsgid());
stMsgHandleResult.iNeedResponse = 0;
stMsgHandleResult.stResponseMsg.Clear();
iRet = ProcessMsg(stMsgHandleResult);
if (0 == iRet)
{
// 不需要回复
if (!stMsgHandleResult.iNeedResponse)
{
continue;
}
iRet = EncodeAndSendMsg(stMsgHandleResult);
if (iRet != 0)
{
TRACE_THREAD(m_iThreadIdx, "Error: encode and push fail. rt:%d\n", iRet);
}
}
}
}
else
{
//no msg in
break;
}
}
usleep(APP_ROLEDB_MAX_SLEEP_USEC);
}
return 0;
}
void CThreadRedis::MyProcess()
{
int iRet = 0;
int iLen = 0;
while (true)
{
iLen = 0;
iRet = 0;
//每次循环之前都清空之前的记录
m_stGameMsg.Clear();
memset(m_szMyCodeBuf,0,sizeof(m_szCodeBuf));
iRet = m_pMyCodeQueue->GetHeadCode(m_szMyCodeBuf, &iLen);
if(iRet < 0 || iLen <= (int)sizeof(unsigned short))
{
//printf("%d_MyProcess break\n",m_iThreadIdx);
break;
}
else
{
//printf("total size:%d\n",iLen);
iRet = m_ProtoEngine.Decode((unsigned char*)m_szMyCodeBuf,iLen,&m_stGameMsg);
if(!iRet)
{
// Redis_GetUserInfo_Request stRequest = m_stGameMsg.m_stmsgbody().m_stuserkeyrequst();
// unsigned int uiMsgID = m_stGameMsg.m_stmsghead().m_uimsgid();
// printf("Receive code OK, idx = %d,Uin = %u, MsgID = %u,strKey=%s,MsgIdx=%u\n"
// ,m_iThreadIdx
// ,m_stGameMsg.m_stmsghead().m_uid()
// ,uiMsgID
// ,stRequest.strkey().c_str()
// ,m_stGameMsg.m_stmsghead().m_msgidx());
// LPJOB_PROC pJobProc = Singleton<CProtoProcMgr>::GetInstance().FindProc(uiMsgID);
// Singleton<CProtoProcMgr>::GetInstance().ExeMsg(uiMsgID,&m_RedisClient,&m_stGameMsg);
// pJobProc(&m_RedisClient,&m_stGameMsg);
iRet = ProcessMsg();
if(iRet == 0)
{
EncodeAndSendMsg();
}
}
else
{
printf("Decode Protocol buf failed %d\n",iRet);
}
}
}
}
int WriteMsg(place_t placeToWriteMsg, int msgType, uint64_t sizeOfBlob, void * blob) {
writeDebug("started writing msg");
int success = ProcessMsg(placeToWriteMsg, msgType, sizeOfBlob, blob);
writeDebugExtraPlace("Finished writing msg to place ",placeToWriteMsg);
if (success == EXIT_SUCCESS) {
return EXIT_SUCCESS;
} else {
return EXIT_FAILURE;
}
}
void CMain_Reactor::BeginWork()
{
bExit_ = false;
while(!bExit_)
{
std::queue<CMessage*> qmsg;
PopAllMsg(qmsg);
while(!qmsg.empty())
{
CMessage* Msg = qmsg.front();
qmsg.pop();
ProcessMsg(Msg);
}
}
}
///////////////////////////////////////////
//// RF24 Radio transmitter
void TRf24Radio::TReadThread::Run() {
Notify->OnNotifyFmt(TNotifyType::ntInfo, "Starting read thread ...");
uint16 FromNode;
uchar Type;
TMem Payload;
Payload.Gen(PAYLOAD_LEN);
TMsgInfoV QueuedMsgV;
while (true) {
try {
// process queued messages
{
TLock Lock(Radio->CriticalSection);
// process new messages
Radio->UpdateNetwork();
while (Radio->Read(FromNode, Type, Payload)) {
Notify->OnNotifyFmt(ntInfo, "Read message, adding to queue ...");
AddToQueue(TMsgInfo(FromNode, Type, Payload));
}
if (!MsgQ.Empty()) {
Notify->OnNotifyFmt(ntInfo, "Adding %d messages to queue ...", MsgQ.Len());
QueuedMsgV.AddV(MsgQ);
MsgQ.Clr();
}
}
if (!QueuedMsgV.Empty()) {
Notify->OnNotifyFmt(ntInfo, "Processing %d messages ...", QueuedMsgV.Len());
for (int MsgN = 0; MsgN < QueuedMsgV.Len(); MsgN++) {
const TMsgInfo& Msg = QueuedMsgV[MsgN];
ProcessMsg(Msg.Val1, Msg.Val2, Msg.Val3);
}
Notify->OnNotify(ntInfo, "Queued messages processed!");
QueuedMsgV.Clr();
}
delayMicroseconds(500);
} catch (const PExcept& Except) {
Notify->OnNotifyFmt(TNotifyType::ntErr, "Error on the read thread: %s", Except->GetMsgStr().CStr());
}
}
}
int WriteMsg(int placeToWriteMsg, int msgType, unsigned long long sizeOfBlob, void * blob) {
if (OUTPUT_ERROR)
fprintf(stderr, "%d:started writing msg\n", _here());
tpl_node* tn;
ProcessMsg(&tn, placeToWriteMsg, msgType, sizeOfBlob, blob);
if (OUTPUT_ERROR)
fprintf(stderr, "%d:Dumping to file Descriptor %d\n", _here(),
placeToWriteMsg);
int pthreadRet1;
int pthreadRet2;
pthread_mutex_t writeLock = getMutexLock();
pthreadRet1 = pthread_mutex_lock(&writeLock);
int success = tpl_dump(tn, TPL_FD, placeToWriteMsg);
pthreadRet2 = pthread_mutex_unlock(&writeLock);
if(pthreadRet1==EXIT_FAILURE){
fprintf(stderr, "%d:Thread locked unsuccessful msg\n", _here());
}else if(pthreadRet2==EXIT_FAILURE){
fprintf(stderr, "%d:Thread unlocked unsuccessful\n", _here());
}else{
fprintf(stderr, "%d:thread locked and unlocked successful\n", _here());
}
if (OUTPUT_ERROR) {
if (success == 0) {
fprintf(stderr, "%d:msg read on file descriptor %d\n", _here(),
placeToWriteMsg);
} else {
fprintf(stderr, "%d:msg read on file descriptor %d FAILED\n",
_here(), placeToWriteMsg);
return EXIT_FAILURE;
}
}
tpl_free(tn);
if (success) {
return EXIT_SUCCESS;
} else {
return EXIT_FAILURE;
}
}
int DoMsgProcess(void *Obj, int ExitCommand)
{
TMsg msg;
int i;
msg.Object=Obj;
do
{
msg.Message=0;
i=GetMsg(&msg);
if(TranslateMsg(i, &msg))
{
while(msg.Message && !((msg.Message==MSG_TYPE_CMD) && (msg.Param1==ExitCommand)))
{
if(!ProcessMsg(&msg)) break;
}
}
}while(!((msg.Message==MSG_TYPE_CMD) && (msg.Param1==ExitCommand)));
return msg.Param2;
}
//
/// The inner message loop. Retrieves and processes messages from the OWL
/// application's message queue until it is empty. Sets BreakMessageLoop if a WM_QUIT
/// passes through. Calls ProcessAppMsg for each message to allow special pre-handling.
//
bool
TMsgThread::PumpWaitingMessages()
{
MSG msg;
bool foundOne = false;
while (::PeekMessage(&msg, 0, 0, 0, PM_REMOVE)) {
foundOne = true;
if (msg.message == WM_QUIT) {
BreakMessageLoop = true;
MessageLoopResult = msg.wParam;
::PostQuitMessage(msg.wParam); // make sure all loops exit
break;
}
bool shouldBreak = ProcessMsg(msg);
if (shouldBreak)
break;
}
return foundOne;
}
static LRESULT CALLBACK
WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
LOG(("got message [msg=%x wparam=%x lparam=%x]\n", uMsg, wParam, lParam));
if (uMsg == WM_COPYDATA) {
if (ipcShutdown) {
LOG(("ignoring message b/c daemon is shutting down\n"));
return TRUE;
}
COPYDATASTRUCT *cd = (COPYDATASTRUCT *) lParam;
if (cd && cd->lpData) {
ipcMessage msg;
PRUint32 bytesRead;
PRBool complete;
// XXX avoid extra malloc
PRStatus rv = msg.ReadFrom((const char *) cd->lpData, cd->cbData,
&bytesRead, &complete);
if (rv == PR_SUCCESS && complete) {
//
// grab client PID and hwnd.
//
ProcessMsg((HWND) wParam, (PRUint32) cd->dwData, &msg);
}
else
LOG(("ignoring malformed message\n"));
}
return TRUE;
}
if (uMsg == IPC_WM_SENDMSG) {
HWND hWndDest = (HWND) wParam;
ipcMessage *msg = (ipcMessage *) lParam;
COPYDATASTRUCT cd;
cd.dwData = GetCurrentProcessId();
cd.cbData = (DWORD) msg->MsgLen();
cd.lpData = (PVOID) msg->MsgBuf();
LOG(("calling SendMessage...\n"));
SendMessage(hWndDest, WM_COPYDATA, (WPARAM) hWnd, (LPARAM) &cd);
LOG((" done.\n"));
delete msg;
return 0;
}
if (uMsg == WM_TIMER) {
PurgeStaleClients();
return 0;
}
#if 0
if (uMsg == IPC_WM_SHUTDOWN) {
//
// since this message is handled asynchronously, it is possible
// that other clients may have come online since this was issued.
// in which case, we need to ignore this message.
//
if (ipcClientCount == 0) {
ipcShutdown = PR_TRUE;
PostQuitMessage(0);
}
return 0;
}
#endif
return DefWindowProc(hWnd, uMsg, wParam, lParam);
}
void TftpdConsole (void *param)
{
SOCKET sDlg;
int Rc;
int nTriggeredEvent;
static struct S_ConsoleMsg msg;
enum e_Events { EV_TOGUI, EV_FROMGUI, EV_NUMBER };
HANDLE tEvents [EV_NUMBER];
// open logging facility
StartAsyncMessagingFacility ( );
do
{
LogToMonitor ("opening comm socket\n");
SetGuiStatus (NOT_CONNECTED);
sDlg = WaitForGuiConnection (); // fail only if thread ends
if (sDlg==INVALID_SOCKET) continue;
// Verify Versions
LogToMonitor ("Verify Console/GUI parameters\n");
Rc = TcpExchangeChallenge (sDlg, 0x56AE, CURRENT_PROTOCOL_VERSION, NULL, sSettings.szConsolePwd);
if ( Rc < 0 )
{
Sleep (1000);
continue;
}
LogToMonitor ( "Version check OK\n" );
SetGuiStatus (CONNECTED);
// Startup blocking service by creating
// one event and one semaphore to code the blocking sendmsgrequest
hMsgRequestSemaf = CreateMutex(NULL, 0, NULL);
hEvMsgSent = CreateEvent(NULL,FALSE,FALSE,NULL);
if (hMsgRequestSemaf==NULL)
CMsgBox (NULL, "Can not create resource", APPLICATION, MB_OK | MB_ICONERROR);
tThreads[TH_CONSOLE].bInit = TRUE; // inits OK
// Create Socket Event
tEvents [EV_FROMGUI] = WSACreateEvent();
WSAEventSelect (sDlg, tEvents[EV_FROMGUI], FD_READ | FD_CLOSE);
do
{
// waits either internal sollicitation or msg reception
tEvents[EV_TOGUI] = tThreads[TH_CONSOLE].hEv;
nTriggeredEvent = WaitForMultipleObjects (EV_NUMBER, tEvents, FALSE, INFINITE);
switch (nTriggeredEvent)
{
case EV_FROMGUI :
// WSA events should be manually reset
WSAEventSelect (sDlg, 0, 0);
ResetEvent (tEvents[EV_FROMGUI]);
Rc = TcpPPRecv (sDlg, (void *) &msg, sizeof msg, 10, INVALID_HANDLE_VALUE);
if (Rc>0) LOG (9, "received %d bytes from console", Rc);
if (Rc>0) ProcessMsg (sDlg, &msg);
else LogToMonitor ("rcvd error %d/%d in console\n", Rc, GetLastError ());
WSAEventSelect (sDlg, tEvents[EV_FROMGUI], FD_READ | FD_CLOSE);
break;
// message to be sent to Gui (except logs)
case EV_TOGUI :
ProcessAsyncMessages ( sDlg, hEvMsgSent );
break;
} // switch signalled events
}
while (tThreads[TH_CONSOLE].gRunning && (Rc>0 || Rc==TCP4U_TIMEOUT) );
WSACloseEvent (tEvents [EV_FROMGUI]); tEvents [EV_FROMGUI] = INVALID_HANDLE_VALUE;
closesocket (sDlg);
// blocking service not available
CloseHandle (hEvMsgSent); hEvMsgSent = INVALID_HANDLE_VALUE;
CloseHandle (hMsgRequestSemaf); hMsgRequestSemaf = INVALID_HANDLE_VALUE;
LogToMonitor ("end of GUI session\n");
}
while ( tThreads[TH_CONSOLE].gRunning );
// terminate therad : don't listen anymore
// closesocket (sListen);
// unblock some threads
SetEvent (hEvMsgSent); Sleep (10); SetEvent (hEvMsgSent);
// stop logging service
StopAsyncMessagingFacility ();
LogToMonitor ("End of console thread\n");
_endthread ();
} // TftpdConsole
int CContainerEventHandler::OnEventFire(void* pvParam) {
//printf("CContainerEventHandler::OnEventFire come in \n");
CMsgQueue* rpMsgq;
m_pMQManager->GetMsgQueue(m_iMqKey,rpMsgq);
//每轮循环中，尝试取两个消息。一个是简单的REQUEST类型。
//另一个是跟本进程相关的msgq消息，对应于本机的服务间互调。
MsgBuf_T stMsg;
stMsg.Reset();
stMsg.lType = REQUEST;
CCmd oCmd;
int Len = 0;
int iret = rpMsgq->GetMsg(&stMsg,Len);
if (Len == 0) {
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = DEFAULT_EPOLL_WAIT_TIME;
select(0,NULL,NULL,NULL,&tv); //纯纯的sleep
//return 0;
//stMsg.Reset();
int iPid = getpid();
stMsg.lType = iPid * 10 + APP;
//printf("try to check app reponse_%d\n", stMsg.lType);
//Len = 0;
iret = rpMsgq->GetMsg(&stMsg,Len);
if (Len == 0) {
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = DEFAULT_EPOLL_WAIT_TIME;
select(0,NULL,NULL,NULL,&tv); //纯纯的sleep
return 0;
}
else {
printf("get APP_RESPONSE_%d Msg lenth:%d,data is %s\n", iPid,Len,stMsg.sBuf);
}
//CCmd oCmd;
oCmd.InitCCmd(stMsg.sBuf);
ProcessMsg(oCmd);
return 0;
}
else {
printf("get REQUEST Msg lenth:%d,data is %s\n",Len,stMsg.sBuf);
}
//CCmd oCmd;
oCmd.InitCCmd(stMsg.sBuf);
if (oCmd.iSvcSerialNo) {
printf("-----It's a Request from app %d----\n",oCmd.iSvcSerialNo);
}
ProcessMsg(oCmd);
/*
map<int,CServiceDispatcher*>::iterator it = m_mapPSvcDispatcher.find(oCmd.iCmd);
if (it != m_mapPSvcDispatcher.end()) {
int iRet = it->second->Dispatch(oCmd);
if (iRet != 0 && iRet != UNFINISH_TASK_RET_FLAG) {
oCmd.iRet = iRet;
oCmd.sData = "resp=Err happend!";
}
else if (iRet == UNFINISH_TASK_RET_FLAG) { //未做完的任务等待再次被唤醒继续完成
return 0;
}
stringstream ss;
ss<<oCmd.sData<<" by pid:" << getpid();
oCmd.sData = ss.str();
m_pMQManager->GetMsgQueue(NET_IO_BACK_MSQ_KEY,rpMsgq);
MsgBuf_T stMsg2;
stMsg2.Reset();
stMsg2.lType = RESPONSE;
oCmd.iType = RESPONSE; //这里的设置没什么意义，因为netio不认这字段。走到这一步，都是方法调用全部做完了。
oCmd.ToString(stMsg2.sBuf,sizeof(stMsg2.sBuf));
rpMsgq->PutMsg(&stMsg2,strlen(stMsg2.sBuf));
RespNotify();
}
else {
printf("can't find:%d dispatcher\n",oCmd.iCmd);
}*/
return 0;
}
void CatchupReader::OnMessageRead(const ByteString& message)
{
if (msg.Read(message))
ProcessMsg();
}
