void InfoModelManager::HandleRows (QAbstractItemModel *model, int from, int to)
{
for (int i = from; i <= to; ++i)
{
const auto& idx = model->index (i, JobHolderColumn::JobProgress);
if (IsInternal (idx))
continue;
const auto row = idx.data (CustomDataRoles::RoleJobHolderRow).value<JobHolderRow> ();
if (row != JobHolderRow::DownloadProgress &&
row != JobHolderRow::ProcessProgress)
continue;
if (idx.data (ProcessState::Done) == idx.data (ProcessState::Total))
continue;
auto ourItem = new QStandardItem;
const auto& name = model->index (i, JobHolderColumn::JobName).data ().toString ();
ourItem->setData (name, InfoModel::Name);
PIdx2Item_ [idx] = ourItem;
HandleData (model, i, i);
Model_->appendRow (ourItem);
}
}
void EHSServer::HandleData_Threaded ( )
{
#define HANDLEDATA_THREADEDSELECTTIMEOUTMILLISECONDS 1000
pthread_t nMyThreadId = pthread_self ( );
MUTEX_LOCK ( m_oMutex );
int ThreadIndex = m_ThreadsSyncPoint.GetNewThreadIndex ();
m_iActiveThreadCount++;
MUTEX_UNLOCK ( m_oMutex );
do {
//fprintf ( stderr, "##### [%d] Thread HandleData\n", nMyThreadId );
HandleData ( HANDLEDATA_THREADEDSELECTTIMEOUTMILLISECONDS,
nMyThreadId );
MUTEX_LOCK ( m_oMutex );
m_ThreadsSyncPoint.SyncThreadIndex ( ThreadIndex );
MUTEX_UNLOCK ( m_oMutex );
} while ( m_nServerRunningStatus != SERVERRUNNING_NOTRUNNING &&
( m_nServerRunningStatus == SERVERRUNNING_THREADPOOL ||
pthread_equal(nMyThreadId,m_nAcceptThreadId) ) );
//fprintf ( stderr, "##### [%d] Thread exiting\n", nMyThreadId );
MUTEX_LOCK ( m_oMutex );
m_iActiveThreadCount--;
MUTEX_UNLOCK ( m_oMutex );
}
void InfoModelManager::handleDataChanged (const QModelIndex& topLeft, const QModelIndex& bottomRight)
{
if (bottomRight.column () < JobHolderColumn::JobProgress)
return;
auto model = qobject_cast<QAbstractItemModel*> (sender ());
HandleData (model, topLeft.row (), bottomRight.row ());
}
void StreamListFetcherBase::handleReplyFinished ()
{
auto reply = qobject_cast<QNetworkReply*> (sender ());
if (!reply)
return;
reply->deleteLater ();
HandleData (reply->readAll ());
}
void NetBase::UnPackData(int length, int start)
{
if(length <= 0)
{
//error.
return;
}
int needLength;
//new data.
if(readDataTemp.data == NULL)
{
readDataTemp.dataLength = Converter::getInt(data, start);
start -= 4; //因为Converter::getInt 会修改start的数值,故需要还原回去.
if(readDataTemp.dataLength <= 0)
{
//error.
readDataTemp.data = NULL;
return;
}
readDataTemp.data = new Byte[readDataTemp.dataLength];
//copy data.
readDataTemp.index = MIN(readDataTemp.dataLength, length);
for(int i = 0; i < readDataTemp.index; i++)
{
readDataTemp.data[i] = data[i+start];
}
needLength = readDataTemp.dataLength;
}
else
{
needLength = readDataTemp.dataLength - readDataTemp.index;
int min = MIN(needLength, length);
for(int i = 0; i < min; i++)
{
readDataTemp.data[i+readDataTemp.index] = data[i+start];
}
readDataTemp.index += min;
}
if(length >= needLength)
{
//pushReadData();
HandleData(readDataTemp.data);
readDataTemp.data = NULL;
}
if(length > needLength)
{
UnPackData(length - needLength, needLength + start);
}
}
/* This function checks if the next word is Virtual instruction
(like .string or .data) */
int CheckIfVirtualInstruction(char *line , int isLabel)
{
int i;
char *word;
/* Set i position for case you have label and for case you don't have a label */
i = isLabel ? isLabel+2 : 0;
/* Ignore spaces */
while(isspace(line[i]))
i++;
/* Check if */
if(line[i++]=='.')
{
word=GetWord(&line[i],' ');
if(strcmp(word,"data")==0)
{
if(isLabel>0)
{
SetLabel(line,(int)isLabel,DATA,0,0,(int)DC);
}
/* Step over .data word in line */
i+=5;
/* Ignore spaces */
while(isspace(line[i]))
i++;
HandleData(&line[i]);
return 1;
}
else if(strcmp(word,"string")==0)
{
if(isLabel>0)
{
SetLabel(line,(int)isLabel,DATA,0,0,(int)DC);
}
/* Step over .string word in line */
i += 7;
/* Step over space */
while(isspace(line[i]))
i++;
HandleString(&line[i]);
return 1;
}
}
else
{
return 0;
}
return 0;
}
void NodePressurePlate::activate(ActivationType a, void * data){
if(a == COLLISION){
Entity *e = static_cast<Entity*>(data);
if(!heavy || (heavy && e->isHeavy())){
if(!isDown){
setHandleData(0, HandleData(true));
}
isDown = true;
lastDownTick = getTickCount();
}
}
}
void ShuffleRound::ProcessData(const QByteArray &data, const Id &id)
{
QByteArray payload;
if(!Verify(data, payload, id)) {
return;
}
QDataStream stream(payload);
int mtype;
QByteArray session_id;
stream >> mtype >> session_id;
MessageType msg_type = (MessageType) mtype;
Id sid(session_id);
if(sid != GetId()) {
qWarning() << "Invalid session, expected " << GetId().ToString()
<< ", found " << sid.ToString();
return;
}
_in_log.Append(data, id);
switch(msg_type) {
case PublicKeys:
HandlePublicKeys(stream, id);
break;
case Data:
HandleData(stream, id);
break;
case ShuffleData:
HandleShuffle(stream, id);
break;
case EncryptedData:
HandleDataBroadcast(stream, id);
break;
case GoMessage:
HandleVerification(true, id);
break;
case NoGoMessage:
HandleVerification(false, id);
break;
case PrivateKey:
HandlePrivateKey(stream, id);
break;
default:
qWarning() << "Unknown message type: " << MessageTypeToString(msg_type)
<< " from " << id.ToString();
return;
}
}
int Detector::Consider(const char *data, int length) {
if (HandleData(data, length) == NS_ERROR_OUT_OF_MEMORY) {
// Error, signal with a negative number
return -1;
}
if (mDone) {
// Detected early
return 0;
}
// Need more data!
return 1;
}
void NodeTimer::doGameUpdate(float updateFactor){
if(run){
currentDelay -= updateFactor;
if(currentDelay <= 0){
run = false;
currentDelay = delay;
setHandleData(0, HandleData(targetState));
}
}
// if(isDown && lastDownTick != getTickCount()){
// isDown = false;
// setHandleData(0, HandleData(false));
// }
}
void NodeAnd::onInputChanged(int handleId){
Node::onInputChanged(handleId);
if(hasHandleData(0) && hasHandleData(1) && getInputHandleData(0).b && getInputHandleData(1).b){
setHandleData(0, HandleData(true));
positive = true;
}
else{
setHandleData(0, HandleData(false));
positive = false;
}
// if(getActivation() == getIngoingCount()){
// for(Node *n : outgoing){
// n->onInputChanged(getUniqueId(), true);
// }
// }
// else{
// for(Node *n : outgoing){
// n->onInputChanged(getUniqueId(), false);
// }
// }
}
void HTTPProxyHandler::HandleSockRecv(const boost::system::error_code & ecode, std::size_t len)
{
LogPrint(eLogDebug,"--- HTTP Proxy sock recv: ", len);
if(ecode)
{
LogPrint(eLogWarning," --- HTTP Proxy sock recv got error: ", ecode);
Terminate();
return;
}
if (HandleData(m_http_buff, len))
{
if (m_state == DONE)
{
LogPrint(eLogInfo,"--- HTTP Proxy requested: ", m_url);
GetOwner()->CreateStream (std::bind (&HTTPProxyHandler::HandleStreamRequestComplete,
shared_from_this(), std::placeholders::_1), m_address, m_port);
}
else
AsyncSockRead();
}
}
void CALLBACK Proc(HMIDIIN hMidiIn, UINT wMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
switch (wMsg)
{
case MM_MIM_OPEN:
DebugPrint("MIDI Input Open\n");
break;
case MM_MIM_CLOSE:
DebugPrint("MIDI Input Close\n");
break;
case MM_MIM_DATA:
HandleData(dwInstance, dwParam1, dwParam2);
break;
case MM_MIM_LONGDATA:
HandleLongData(dwInstance, dwParam1, dwParam2);
break;
case MM_MIM_ERROR:
DebugPrint("MIDI Input Error: %08x %08x\n", dwParam1, dwParam2);
break;
case MM_MIM_LONGERROR:
DebugPrint("MIDI Input Long Error: %08x %08x\n", dwParam1, dwParam2);
break;
}
}
void NodePressurePlate::doGameUpdate(float updateFactor){
if(isDown && lastDownTick != getTickCount()){
isDown = false;
setHandleData(0, HandleData(false));
}
}
void main()
{
HandleData(0,NULL,NULL);
}
void MuHttpServer::processServer()
{
HandleData(0);
}
UCDetect::UCDetect(const std::string &file)
: nsUniversalDetector(NS_FILTER_ALL)
{
{
agi::scoped_ptr<std::ifstream> fp(io::Open(file, true));
// If it's over 100 MB it's either binary or big enough that we won't
// be able to do anything useful with it anyway
fp->seekg(0, std::ios::end);
if (fp->tellg() > 100 * 1024 * 1024) {
list.emplace_back(1.f, "binary");
return;
}
fp->seekg(0, std::ios::beg);
std::streamsize binaryish = 0;
std::streamsize bytes = 0;
while (!mDone && *fp) {
char buf[4096];
fp->read(buf, sizeof(buf));
std::streamsize read = fp->gcount();
HandleData(buf, (PRUint32)read);
// A dumb heuristic to detect binary files
if (!mDone) {
bytes += read;
for (std::streamsize i = 0; i < read; ++i) {
if ((unsigned char)buf[i] < 32 && (buf[i] != '\r' && buf[i] != '\n' && buf[i] != '\t'))
++binaryish;
}
if (binaryish > bytes / 8) {
list.emplace_back(1.f, "binary");
return;
}
}
}
}
DataEnd();
if (mDetectedCharset)
list.emplace_back(1.f, mDetectedCharset);
else {
switch (mInputState) {
case eHighbyte: {
for (PRInt32 i=0; i<NUM_OF_CHARSET_PROBERS; i++) {
if (!mCharSetProbers[i]) continue;
float conf = mCharSetProbers[i]->GetConfidence();
if (conf > 0.01f)
list.emplace_back(conf, mCharSetProbers[i]->GetCharSetName());
}
break;
}
case ePureAscii:
list.emplace_back(1.f, "US-ASCII");
break;
default:
throw UnknownCharset("Unknown character set.");
}
if (list.empty() && (mInputState == eHighbyte))
throw UnknownCharset("Unknown character set.");
typedef std::pair<float, std::string> const& result;
sort(begin(list), end(list), [](result lft, result rgt) { return lft.first > rgt.first; });
}
}
JSBool
js_ConsumeJSONText(JSContext *cx, JSONParser *jp, const jschar *data, uint32 len)
{
uint32 i;
if (*jp->statep == JSON_PARSE_STATE_INIT) {
PushState(jp, JSON_PARSE_STATE_OBJECT_VALUE);
}
for (i = 0; i < len; i++) {
jschar c = data[i];
switch (*jp->statep) {
case JSON_PARSE_STATE_VALUE :
if (c == ']') {
// empty array
if (!PopState(jp))
return JS_FALSE;
if (*jp->statep != JSON_PARSE_STATE_ARRAY)
return JS_FALSE; // unexpected char
if (!CloseArray(cx, jp) || !PopState(jp))
return JS_FALSE;
break;
}
if (c == '}') {
// we should only find these in OBJECT_KEY state
return JS_FALSE; // unexpected failure
}
if (c == '"') {
*jp->statep = JSON_PARSE_STATE_STRING;
break;
}
if (IsNumChar(c)) {
*jp->statep = JSON_PARSE_STATE_NUMBER;
js_AppendChar(jp->buffer, c);
break;
}
if (JS7_ISLET(c)) {
*jp->statep = JSON_PARSE_STATE_KEYWORD;
js_AppendChar(jp->buffer, c);
break;
}
// fall through in case the value is an object or array
case JSON_PARSE_STATE_OBJECT_VALUE :
if (c == '{') {
*jp->statep = JSON_PARSE_STATE_OBJECT;
if (!OpenObject(cx, jp) || !PushState(jp, JSON_PARSE_STATE_OBJECT_PAIR))
return JS_FALSE;
} else if (c == '[') {
*jp->statep = JSON_PARSE_STATE_ARRAY;
if (!OpenArray(cx, jp) || !PushState(jp, JSON_PARSE_STATE_VALUE))
return JS_FALSE;
} else if (!JS_ISXMLSPACE(c)) {
return JS_FALSE; // unexpected
}
break;
case JSON_PARSE_STATE_OBJECT :
if (c == '}') {
if (!CloseObject(cx, jp) || !PopState(jp))
return JS_FALSE;
} else if (c == ',') {
if (!PushState(jp, JSON_PARSE_STATE_OBJECT_PAIR))
return JS_FALSE;
} else if (c == ']' || !JS_ISXMLSPACE(c)) {
return JS_FALSE; // unexpected
}
break;
case JSON_PARSE_STATE_ARRAY :
if (c == ']') {
if (!CloseArray(cx, jp) || !PopState(jp))
return JS_FALSE;
} else if (c == ',') {
if (!PushState(jp, JSON_PARSE_STATE_VALUE))
return JS_FALSE;
} else if (!JS_ISXMLSPACE(c)) {
return JS_FALSE; // unexpected
}
break;
case JSON_PARSE_STATE_OBJECT_PAIR :
if (c == '"') {
// we want to be waiting for a : when the string has been read
*jp->statep = JSON_PARSE_STATE_OBJECT_IN_PAIR;
if (!PushState(jp, JSON_PARSE_STATE_STRING))
return JS_FALSE;
} else if (c == '}') {
// pop off the object pair state and the object state
if (!CloseObject(cx, jp) || !PopState(jp) || !PopState(jp))
return JS_FALSE;
} else if (c == ']' || !JS_ISXMLSPACE(c)) {
return JS_FALSE; // unexpected
}
break;
case JSON_PARSE_STATE_OBJECT_IN_PAIR:
if (c == ':') {
*jp->statep = JSON_PARSE_STATE_VALUE;
} else if (!JS_ISXMLSPACE(c)) {
return JS_FALSE; // unexpected
}
break;
case JSON_PARSE_STATE_STRING:
if (c == '"') {
if (!PopState(jp))
return JS_FALSE;
JSONDataType jdt;
if (*jp->statep == JSON_PARSE_STATE_OBJECT_IN_PAIR) {
jdt = JSON_DATA_KEYSTRING;
} else {
jdt = JSON_DATA_STRING;
}
if (!HandleData(cx, jp, jdt, jp->buffer->base, STRING_BUFFER_OFFSET(jp->buffer)))
return JS_FALSE;
} else if (c == '\\') {
*jp->statep = JSON_PARSE_STATE_STRING_ESCAPE;
} else {
js_AppendChar(jp->buffer, c);
}
break;
case JSON_PARSE_STATE_STRING_ESCAPE:
switch(c) {
case '"':
case '\\':
case '/':
break;
case 'b' : c = '\b'; break;
case 'f' : c = '\f'; break;
case 'n' : c = '\n'; break;
case 'r' : c = '\r'; break;
case 't' : c = '\t'; break;
default :
if (c == 'u') {
jp->numHex = 0;
jp->hexChar = 0;
*jp->statep = JSON_PARSE_STATE_STRING_HEX;
continue;
} else {
return JS_FALSE; // unexpected
}
}
js_AppendChar(jp->buffer, c);
*jp->statep = JSON_PARSE_STATE_STRING;
break;
case JSON_PARSE_STATE_STRING_HEX:
if (('0' <= c) && (c <= '9'))
jp->hexChar = (jp->hexChar << 4) | (c - '0');
else if (('a' <= c) && (c <= 'f'))
jp->hexChar = (jp->hexChar << 4) | (c - 'a' + 0x0a);
else if (('A' <= c) && (c <= 'F'))
jp->hexChar = (jp->hexChar << 4) | (c - 'A' + 0x0a);
else
return JS_FALSE; // unexpected
if (++(jp->numHex) == 4) {
js_AppendChar(jp->buffer, jp->hexChar);
jp->hexChar = 0;
jp->numHex = 0;
*jp->statep = JSON_PARSE_STATE_STRING;
}
break;
case JSON_PARSE_STATE_KEYWORD:
if (JS7_ISLET(c)) {
js_AppendChar(jp->buffer, c);
} else {
// this character isn't part of the keyword, process it again
i--;
if(!PopState(jp))
return JS_FALSE;
if (!HandleData(cx, jp, JSON_DATA_KEYWORD, jp->buffer->base, STRING_BUFFER_OFFSET(jp->buffer)))
return JS_FALSE;
}
break;
case JSON_PARSE_STATE_NUMBER:
if (IsNumChar(c)) {
js_AppendChar(jp->buffer, c);
} else {
// this character isn't part of the number, process it again
i--;
if(!PopState(jp))
return JS_FALSE;
if (!HandleData(cx, jp, JSON_DATA_NUMBER, jp->buffer->base, STRING_BUFFER_OFFSET(jp->buffer)))
return JS_FALSE;
}
break;
case JSON_PARSE_STATE_FINISHED:
if (!JS_ISXMLSPACE(c))
return JS_FALSE; // extra input
break;
default:
JS_NOT_REACHED("Invalid JSON parser state");
}
}
return JS_TRUE;
}
bool EncodingDetector::DetectEncoding(const wxByte* buffer, size_t size, bool convert_to_wxstring)
{
ConfigManager* cfgMgr = Manager::Get()->GetConfigManager(_T("editor"));
wxString encname = cfgMgr->Read(_T("/default_encoding"));
if (cfgMgr->ReadInt(_T("/default_encoding/use_option"), 0) == 1)
{
// Bypass C::B's auto-detection
m_Encoding = wxFontMapper::Get()->CharsetToEncoding(encname, false);
if (m_UseLog)
{
wxString msg;
msg.Printf(_T("Warning: bypassing C::B's auto-detection!\n"
"Encoding requested is: %s (ID: %d)"),
wxFontMapper::Get()->GetEncodingDescription(m_Encoding).c_str(),
m_Encoding);
Manager::Get()->GetLogManager()->DebugLog(msg);
}
}
else
{
if (!buffer)
return false;
// Try our own detection for UTF-16 and UTF-32, the Mozilla-version does not work without BOM
if ( DetectEncodingEx(buffer, size) )
{
if (m_UseBOM && m_UseLog)
{
wxString msg;
msg.Printf(_T("Detected encoding via BOM: %s (ID: %d)"),
wxFontMapper::Get()->GetEncodingDescription(m_Encoding).c_str(),
m_Encoding);
Manager::Get()->GetLogManager()->DebugLog(msg);
}
}
else
{
//{ MOZILLA nsUniversalDetector START
// If we still have no results try Mozilla (taken from nsUdetXPCOMWrapper.cpp):
Reset(); nsresult res = HandleData((char*)buffer, size);
if (res==NS_OK)
DataEnd();
else
{
m_MozillaResult = wxEmptyString;
if (m_UseLog)
Manager::Get()->GetLogManager()->DebugLog(F(_T("Mozilla universal detection failed with %d."), res));
}
//} MOZILLA nsUniversalDetector END
if ( !m_MozillaResult.IsEmpty() )
m_Encoding = wxFontMapper::Get()->CharsetToEncoding(m_MozillaResult, false);
if (m_Encoding == wxFONTENCODING_DEFAULT)
{
wxString enc_name = Manager::Get()->GetConfigManager(_T("editor"))->Read(_T("/default_encoding"), wxLocale::GetSystemEncodingName());
m_Encoding = wxFontMapper::GetEncodingFromName(enc_name);
if (m_UseLog)
{
wxString msg;
msg.Printf(_T("Text seems to be pure ASCII!\n"
"We use user specified encoding: %s (ID: %d)"),
wxFontMapper::Get()->GetEncodingDescription(m_Encoding).c_str(),
m_Encoding);
Manager::Get()->GetLogManager()->DebugLog(msg);
}
}
if (m_Encoding < 0)
{
// Use user-specified one; as a fallback
m_Encoding = wxFontMapper::Get()->CharsetToEncoding(encname, false);
if (m_UseLog)
{
wxString msg;
msg.Printf(_T("Warning: Using user specified encoding as fallback!\n"
"Encoding fallback is: %s (ID: %d)"),
wxFontMapper::Get()->GetEncodingDescription(m_Encoding).c_str(),
m_Encoding);
Manager::Get()->GetLogManager()->DebugLog(msg);
}
}
m_UseBOM = false;
m_BOMSizeInBytes = 0;
}
}
if (m_UseLog)
{
wxString msg;
msg.Printf(_T("Final encoding detected: %s (ID: %d)"),
wxFontMapper::Get()->GetEncodingDescription(m_Encoding).c_str(),
m_Encoding);
Manager::Get()->GetLogManager()->DebugLog(msg);
}
if (convert_to_wxstring && !ConvertToWxString(buffer, size) && m_UseLog)
Manager::Get()->GetLogManager()->DebugLog(_T("Something seriously went wrong while converting file content to wxString!"));
return true;
}
void PasClient::HandleRecvData( socket_t *sock, const char *data, int len )
{
OUT_RECV( sock->_szIp, sock->_port, "PasClient", "UDP fd %d, Recv: %s", sock->_fd, data ) ;
// 否则是别人的UDP连接过来的数据
if ( strcmp( _srvip.c_str(), sock->_szIp ) != 0 ) {
// 拆分数据
const char *ptr = strstr( data, "|" ) ;
if ( ptr == NULL ) {
OUT_ERROR( sock->_szIp, sock->_port, "Recv", "PasClient UDP fd %d data error", sock->_fd ) ;
return ;
}
char srvid[128] = {0};
memcpy( srvid, data+1, ptr- data -1 ) ;
// 暂时只处理数据通道的心跳
if ( strncmp( ptr+1 , "NOOP", 4 ) == 0 ) {
SendData( sock, data, len ) ;
OUT_INFO( sock->_szIp, sock->_port, srvid, "PasClient UDP fd %d NOOP", sock->_fd ) ;
} else {
_statinfo->AddRecv( sock->_szIp ) ;
vector<string> vec;
if ( ! splitvector( data, vec, "|", 0 ) ) {
OUT_ERROR( sock->_szIp, sock->_port, "Recv", "fd %d, split data error: %s", sock->_fd, data ) ;
return ;
}
// 7
CBase64Ex base64 ;
base64.Decode( vec[7].c_str(), vec[7].length() ) ;
string sdata = "*";
sdata += GetSrvId() ;
sdata += ptr ;
// *0431|GPSPosInfo|1.0.4|XQ|4|P|17|mxJ5B4AqAX4|0|0|118.3315|33.7856|99.98|+93.9|308|1340187770|0|-1|nhs#
if ( HandleData( sdata.c_str(), sdata.length() ) ) {
_statinfo->AddSend( sock->_szIp ) ;
} else {
PCCMSG_LOG( _pEnv->GetLogger(), sock->_szIp, sock->_port, srvid, "ERROR", "发送车牌号%s到服务器失败", base64.GetBuffer() ) ;
}
OUT_PRINT( sock->_szIp, sock->_port, srvid, "%s,PasClient UDP fd %d, HandleData: %s" ,
base64.GetBuffer(), sock->_fd, sdata.c_str() ) ;
bool error = false ;
char szmacid[512] = {0} ;
if ( _pEnv->GetMsgClient()->GetCarMacId( base64.GetBuffer(), szmacid ) ) {
CQString buf , msg ;
if ( PConvert::buildintergps( vec, szmacid, buf , msg ) ) {
// 转换回内部协议发送给MSG
_pEnv->GetMsgClient()->HandleUpMsgData( SEND_ALL, buf.GetBuffer(), buf.GetLength() ) ;
// 打印的数据
OUT_INFO( sock->_szIp, sock->_port, srvid, "fd %d, PasServer %s, Send Data: %s",
sock->_fd, base64.GetBuffer(), buf.GetBuffer() ) ;
} else {
error = true ;
OUT_ERROR( sock->_szIp, sock->_port, srvid, "fd %d, %s, PasClient build inter gps macid %s",
sock->_fd, base64.GetBuffer(), szmacid ) ;
PCCMSG_LOG( _pEnv->GetLogger(), sock->_szIp, sock->_port, srvid, "ERROR", "车牌号%s,错误：%s",
base64.GetBuffer() , msg.GetBuffer() ) ;
}
} else {
error = true ;
OUT_ERROR( sock->_szIp, sock->_port, srvid, "PasClient UDP fd %d, %s get macid failed",
sock->_fd, base64.GetBuffer() ) ;
//PCCMSG_LOG( _pEnv->GetLogger(), ip, port, srvid, "ERROR", "取得车牌号%s值对应关系失败", base64.GetBuffer() ) ;
}
_statinfo->AddVechile( sock->_szIp, base64.GetBuffer(), my_atoi(vec[4].c_str()) , error ) ;
}
} else {
// 如果来自服务器的UDP的数据
PccUser user ;
if ( ! _user.GetUser( sock, user ) ) {
PccUser &udpuser = _user.GetUser( false ) ;
udpuser._fd = sock ;
udpuser.SetOnline() ;
} else {
_user.Update( PCC_USER_ACTVIE, user._tcp ) ;
PccUser &tmpuser = _user.GetUser( false ) ;
tmpuser.SetOnline();
}
vector<string> vec;
if ( ! splitvector( data, vec, "|", 0 ) ) {
OUT_ERROR( sock->_szIp, sock->_port, "Recv", "fd %d, split data error: %s", sock->_fd, data ) ;
return ;
}
if ( vec.size() < 3 ){
OUT_ERROR( sock->_szIp, sock->_port, "Recv", "fd %d, data error: %s", sock->_fd, data ) ;
return ;
}
// 暂时只处理数据通道的心跳
if ( vec[1] == "NOOP" ) {
OUT_RECV( sock->_szIp, sock->_port, "UDP", "Recv fd %d data NOOP" , sock->_fd ) ;
} /*else if ( vec[1] == "QryGPSPosInfo" || vec[1] == "QueryAllGPSData" ) {
PccUser &udp = _user.GetUser(false) ;
SendData( udp._fd, data, len ) ;
OUT_PRINT( NULL, 0, "Send", "%s", data ) ;
}*/
}
}
int
cOpenHpiDaemon::MainLoop()
{
DbgCon( "ready for incomming connections.\n" );
int num_add = 1;
if ( m_interactive )
{
m_pollfd = new pollfd[2];
num_add++;
m_pollfd[1].fd = 0; // stdin
m_pollfd[1].events = POLLIN;
m_pollfd[1].revents = 0;
}
else
m_pollfd = new pollfd[1];
m_pollfd[0].fd = m_main_socket->m_fd;
m_pollfd[0].events = POLLIN;
m_pollfd[0].revents = 0;
while( true )
{
int rv = poll( m_pollfd, m_num_connections + num_add, 250 );
if ( rv < 0 )
{
usleep( 100000 );
if ( errno != EINTR )
fprintf( stderr, "can't poll: %s %d !\n",
strerror( errno ), errno );
// sleep a while
usleep( 100 );
continue;
}
if ( rv == 0 )
{
Idle();
continue;
}
for( int i = m_num_connections - 1; i >= 0; i-- )
if ( m_pollfd[i].revents )
if ( !HandleData( m_connections[i] ) )
{
CloseConnection( i );
// m_pollfd has changed
continue;
}
if ( m_pollfd[m_num_connections].revents )
{
// create new connection
cServerConnection *c = ServerConnectionMainAccept( m_main_socket );
if ( c )
{
NewConnection( c );
continue;
}
}
if ( m_interactive && m_pollfd[m_num_connections+1].revents )
if ( HandleInteractive() == false )
break;
}
return 0;
}
