void CAcmUdp::ProcessOnce(CCooperator* pCooperator, bool &bRunning)
{
if(pCooperator == &m_oRecvThread)
{
if(!RecvMsg(m_oFile))
bRunning = false;
}
else if(pCooperator == &m_oRecvThread2)
{
if(!RecvMsg(m_oUniCastFile))
bRunning = false;
}
else
{
CUdpMsg* pMsg = NULL;
m_oEvent.Wait(1000);
m_oMutex.Enter();
if(m_oMsgQueue.Pop(pMsg))
{
m_oMutex.Leave();
ProcessMessage(pMsg);
if(pMsg)
delete pMsg;
}
else
{
m_oEvent.Reset();
m_oMutex.Leave();
}
}
}
// 函数名: CSvrLink::ToLink
// 编程 : 陈永华 2004-2-11 12:14:25
// 描述 :
// 返回 : int
// 参数 : ST_BUNIT *pBUnit
int CSvrLink::ToLink(ST_BUNIT *pBUnit)
{
int i;
int rtn;
RP_LINKBEGIN rp;
AP_LINKBEGIN *pap;
MSGBUF *pmb;
memset(&head,0,sizeof(head));
iLastReqType = 0;
iLastRetCode = 0;
iGRFrame = 10; // 重新开始的获取请求的帧号，注意在连接初期，必须与BCC不同，以防止不同步
linksock.Close();
rp.bu1 = 1;
strncpy(rp.szBUGroupID,pBUnit->szBUGroupID,sizeof(rp.szBUGroupID)-1);
rp.iDefaultAM = iDefaultAnswerMode;
rp.iBUVersion = htonl(BU_VERSION); // BU的版本编码
if (linksock.ConnectTcp(pBUnit->szSvrIP,pBUnit->iSvrPort))
{
for (i=0;i<5;i++)
{
rtn = SendMsg(MT_LINKBEGIN,sizeof(rp),&rp);
if (rtn!=0)
{
sprintf(buf,"发送连接请求数据的时候失败，SendMsg()=%d，端口失败号为%d\n",rtn,linksock.GetLastError(NULL,0));
DEBUG_RUNTIME_MSGOUT(buf);
return(rtn);
}
rtn = RecvMsg(pBUnit->iHBInterval);
if (rtn>0 && rtn>=(int)(sizeof(MSGHEAD)))
{
pmb = GetRecvMsg();
if (pmb->head.msgtype==MT_LINKBEGIN && pmb->head.len>=sizeof(AP_LINKBEGIN))
{
pap = (AP_LINKBEGIN *)(pmb->data);
svr_hs1 = pap->bc1;
// 无所谓字序的转换了，反正不会重复的，如果需要，这个参数也多数会返回给BCC的
iThisProcID = ntohl(pap->bu_number);
bccBFuncNo = ntohl(pap->basefuncno);
bccID = ntohl(pap->bccid);
if (strlen(pap->szmsg)>0)
{
g_LogFile.WriteLogEx(1000,"BU%d-BCC Warning:%s",iThisProcID,pap->szmsg);
}
return(1); // 成功连接，可以开始处理了
}
}
else if (rtn!=0)
{
sprintf(buf,"接收连接请求数据确认的时候失败，RecvMsg()=%d，端口失败号为%d\n",rtn,linksock.GetLastError(NULL,0));
DEBUG_RUNTIME_MSGOUT(buf);
return(rtn); // 接收时候失败
}
}
linksock.Close();
DEBUG_RUNTIME_MSGOUT("做了5次连接请求都没有应答返回!\n");
return(0);
}
return(-100);
}
//S_S 请求及应答
int SSClient::SSRequest( Packet &packet)
{
int iRet = 0;
//连接
iRet = Connect();
if(iRet<0)
goto EndOfProcess;
DEBUG_PRINTF( "SSRequest: req pkg------- \n" );
DEBUG_SHOWHEX( packet.GetBuffer()->GetReadPtr(), packet.GetBuffer()->GetDataSize(), 0, __FILE__, __LINE__ );
//发送消息
iRet = SendMsg(packet);
if(iRet<0)
goto EndOfProcess;
//缓存清空
packet.GetBuffer()->Reset();
//接收应答
iRet = RecvMsg(packet);
if(iRet<0)
goto EndOfProcess;
DEBUG_PRINTF( "SSRequest: ack pkg------- \n" );
DEBUG_SHOWHEX( packet.GetBuffer()->GetReadPtr()-PACKET_HEADER_LENGTH, packet.GetBuffer()->GetDataSize()+PACKET_HEADER_LENGTH , 0, __FILE__, __LINE__ );
EndOfProcess:
Close();
return iRet;
}
void TmtSocketServer::Task(void)
{
if (m_SkStatus == enRecvOK || m_SkStatus == enSendAndRecvOK)
{
int revLen = RecvMsg((void*)pBuffer, m_BufferSize);
ServerProcess(revLen);
}
}
int CSvrLink::Processing(ST_BUNIT *pBUnit)
{
int rtn;
MSGBUF *pmb;
RP_REQUEST rp;
if (linksock.IsFree())
return(0);
rp.iGRFrame = iGRFrame;
rp.iLastReqType = htonl(iLastReqType);
rp.iLastRetCode = htonl(iLastRetCode);
rtn = SendMsg(MT_GETREQ,sizeof(rp),&rp);
if (rtn!=0)
{
// 连接出现问题了：或被BCC关闭了
return(-1);
}
rtn = RecvMsg(pBUnit->iHBInterval);
if (rtn>=(int)(sizeof(MSGHEAD)))
{
pmb = GetRecvMsg();
switch (pmb->head.msgtype)
{
case MT_LINKBEGIN:
// Update some variables:
if (pmb->head.len>=sizeof(AP_LINKBEGIN))
{
AP_LINKBEGIN *pap;
pap = (AP_LINKBEGIN *)(pmb->data);
svr_hs1 = pap->bc1;
iThisProcID = ntohl(pap->bu_number);
}
break;
case EXITMSGTYPE:
Close();
bExit = true;
break;
case WRITEAPPINFO:
WriteAppInfo(bccBFuncNo,bccID); // 在主框架程序部分
break;
case MT_GETREQ:
// OK,have new request to process
if (pmb->head.len>=sizeof(AP_REQUEST)+sizeof(ST_PACKHEAD))
{
AP_REQUEST *prp = (AP_REQUEST *)(pmb->data);
if (prp->iGRFrame==iGRFrame)
{
CallBPFunction(pmb);
iGRFrame++;
}
}
break;
default:
break;
}
}
return(rtn);
}
// 函数名: CSvrLink::SMRead
// 编程 : 陈永华 2005-7-6 10:21:43
// 描述 : 从指定共享内存空间中读取局部或全部的数据
// 返回 : int -2/-1000:共享内存句柄错误；
// -1:内存空间没有分配；
// 0:读取位置offset超过已经分配的空间
// >0:读取数据长度（如果该值<指定的值，即即为结束）
// -20: 等待超时，BCC没有能够在1秒之内响应
// <-100: 属于各类错误：
// -101:被对方正常关闭；
// -110/-111:对方非标准MSG协议口或数据不同步；
// -102:因为链路错误而被关闭；
// -103:在接收数据的时候，出错而被关闭
// -1001: 长度过长，每次的长度length<=8180
// 参数 : int smh：[IN] 共享内存块句柄，参见SMOpenBlock返回
// 参数 : void *rbuf：[OUT] 读取数据缓存
// 参数 : unsigned int offset：[IN] 读取数据存放在共享内存块的偏移位置
// 参数 : unsigned int rblen：[IN] 读取数据块长度，注意<8180
// 参数 : bool bRLock: [IN] 是否需要加锁读
int CSvrLink::SMRead(int smh, void *rbuf, unsigned int offset, unsigned int rblen, bool bRLock)
{
unsigned char sbuf[MAXMSG];
RP_SMWRITE *pwr; // 这里也是使用写结构进行数据交换
int rtn;
if (smh<0)
return(-1000); // 共享内存块句柄错误，参见SMOpenBlock
pwr = (RP_SMWRITE *)sbuf;
if (rblen>MAXMSG-sizeof(RP_SMWRITE))
return(-1001); // 长度过长，每次的长度length<=8180
pwr->handle = htonl(smh);
pwr->offset = htonl(offset);
pwr->length = htonl(rblen);
pwr->lock = bRLock?1:0;
rtn = SendMsg(MT_SMREAD,sizeof(RP_SMWRITE),sbuf);
if (rtn<0) rtn -= 1000; // 属于严重错误，断开了与BCC的连接，退出
while (rtn==0)
{
// 发送读共享内存块消息成功：
rtn = RecvMsg(1000); // 1秒内应该该有结果了
if (rtn>0)
{
// 收到结果：
MSGBUF *pmb = GetRecvMsg();
if (pmb->head.msgtype==MT_SMREAD)
{
// 收到的即为处理返回的值：
/* ****** Updated by CHENYH at 2006-7-5 16:27:38 ******
rtn = ntohl(*(int *)pmb->data);
*******************************************************/
memcpy(&rtn,pmb->data,sizeof(rtn));
rtn = ntohl(rtn);
// 返回 : int -2:共享内存句柄错误；
// -1:内存空间没有分配；
// 0:读取位置offset超过已经分配的空间
// >0:读取数据长度（如果该值<指定的值，即即为结束）
if (rtn>0)
{
memcpy(rbuf,pmb->data+sizeof(int),rtn);
}
return(rtn);
}
else rtn = 0; // 继续等待对方的应答
}
else if (rtn==0)
{
// 等待超时，BCC没有能够在1秒之内响应
rtn = -20;
}
else
{
// 出错了
rtn -= 100;
}
}
return(rtn);
}
int cCardClientRadegast::Recv(unsigned char *buff, int len)
{
if(RecvMsg(buff,1)<0) {
PRINTF(L_CC_RDGD,"short read");
return -1;
}
int n=GetNanoStart(buff);
if(RecvMsg(buff+1,n-1,200)<0) {
PRINTF(L_CC_RDGD,"short read(2)");
return -1;
}
int k=GetMsgLength(buff);
if(RecvMsg(buff+n,k-n,200)<0) {
PRINTF(L_CC_RDGD,"short read(3)");
return -1;
}
return k;
}
int CSvrLink::IntCall(char *szBUGroupID, int waittime, ST_CPACK *rpack, ST_CPACK *apack, ST_PACK *pArrays)
{
int rtn;
unsigned short len;
unsigned char sbuf[MAXMSG];
char szmsg[256]={0};
RP_INTCALLH *pic = (RP_INTCALLH *)sbuf;
pic->waittime = htonl(waittime);
strncpy(pic->szBUGroupID,szBUGroupID,MAXBUGRPID);
if (rpack->head.recCount>1)
{
rpack->head.recCount = 1;
}
EncodeBuf(rpack,sbuf+sizeof(RP_INTCALLH),&rtn,szmsg);
len = rtn+sizeof(RP_INTCALLH);
rtn=SendMsg(MT_INTCALL,len,sbuf);
while (rtn==0)
{
rtn = RecvMsg(waittime*1000+1000);
if (rtn>0)
{
MSGBUF *pmb = GetRecvMsg();
if (pmb->head.msgtype==MT_PUSHDATA)
{
// 有应答数据返回：
rtn = 0;
DecodeBufWithArray((unsigned char *)pmb->data,pmb->head.len,apack,pArrays,&rtn,szmsg);
//memset(&xcdata,0,sizeof(xcdata)); // 清空
memcpy(&(xcdata.ahead),&(apack->head),sizeof(ST_PACKHEAD));
if (pmb->head.len>=rtn+sizeof(TPUSHDESTN))
{
TPUSHDESTN *pd = (TPUSHDESTN *)(pmb->data+rtn);
xcdata.sno = ntohs(pd->SourceNo);
xcdata.dno = ntohs(pd->DestNo);
xcdata.fno = ntohs(pd->FuncNo);
}
return(rtn);
}
else
{
DEBUG_RUNTIME_MSGOUT("IntCall中间收到了非MT_INTCALL应答包，属于程序错误!");
rtn = 0; // 继续读取数据，以便接收到正确的MT_INTCALL应答包
}
}
else if (rtn==0)
{
return(-2); // 等待应答数据超时，即自从向外发送了请求后，在waittime+1秒内没有接收到应答数据
}
}
return(-1); // 其他各种通讯方面的错误
}
// 函数名: CSvrLink::SMOpenBlock
// 编程 : 陈永华 2005-7-4 15:52:14
// 描述 : 创建或打开一个命名共享内存块
// 返回 : int
// >=0: 成功，返回该共享内存的句柄号；
// -1: 共享内存块（句柄）已经用完了
// -2: 已经需要的共享内存块长度已经超过了BCC限定了
// -3: 要求的长度超过已经分配的共享内存长度
// -20: 等待超时，BCC没有能够在1秒之内响应
// <100: 属于各类错误，-101:被对方正常关闭；-110/-111:对方非标准MSG协议口或数据不同步；-102:因为链路错误而被关闭；-103:在接收数据的时候，出错而被关闭
// 参数 : char *name : 共享内存块命名
// 参数 : unsigned int length: 共享内存块的长度
int CSvrLink::SMOpenBlock(char *name, unsigned int length)
{
unsigned char sbuf[MAXMSG];
RP_SMOPEN *pob;
int rtn;
pob = (RP_SMOPEN *)sbuf;
memcpy(pob->name,name,sizeof(pob->name));
pob->length = htonl(length);
rtn = SendMsg(MT_SMOPEN,sizeof(RP_SMOPEN),sbuf);
if (rtn<0) rtn -= 1000; // 属于严重错误，断开了与BCC的连接，退出
while (rtn==0)
{
// 发送共享打开消息成功：
rtn = RecvMsg(1000); // 1秒内应该该有结果了
if (rtn>0)
{
// 收到结果：
MSGBUF *pmb = GetRecvMsg();
if (pmb->head.msgtype==MT_SMOPEN)
{
// 收到的即为处理返回的值：
/* ****** Updated by CHENYH at 2006-7-5 16:24:46 ******
rtn = ntohl(*(int *)pmb->data);
*******************************************************/
memcpy(&rtn,pmb->data,sizeof(rtn));
rtn = ntohl(rtn);
//>=0: 成功，返回该共享内存的句柄号；
//-1: 共享内存块（句柄）已经用完了
//-2: 已经需要的共享内存块长度已经超过了BCC限定了
//-3: 要求的长度超过已经分配的共享内存长度
return(rtn);
}
else rtn = 0; // 继续等待对方的应答
}
else if (rtn==0)
{
// 等待超时，BCC没有能够在1秒之内响应
rtn = -20;
}
else
{
// 出错了
rtn -= 100;
}
}
return(rtn);
}
int CSvrLink::ExtCall(int sourceno, int destno, int funcno, int batchno, int acktime, ST_CPACK *rpack, ST_CPACK *apack, ST_PACK *pArrays)
{
int rtn;
char szmsg[256];
xcdata.sno = sourceno;
xcdata.dno = destno;
xcdata.fno = funcno;
xcdata.bno = batchno;
rpack->head.userdata = batchno;
if (acktime<=0)
{
acktime = 5; // 缺省为5秒钟内得到应答，否则作为失败处理。。。以防止业务部分调用错误导致整个BUNIT处理失败或挂起
}
rtn = PushData(sourceno,destno,funcno,batchno,rpack,PM_ANSWER,acktime);
while (rtn==0)
{
rtn = RecvMsg(acktime*1000+1000);
if (rtn>0)
{
MSGBUF *pmb = GetRecvMsg();
if (pmb->head.msgtype==MT_PUSHDATA)
{
// 有应答数据返回：
rtn = 0;
DecodeBufWithArray((unsigned char *)pmb->data,pmb->head.len,apack,pArrays,&rtn,szmsg);
memcpy(&xcdata.ahead,&(apack->head),sizeof(ST_PACKHEAD));
if (apack->head.hook.queuetype>0)
xcdata.fno = apack->head.hook.queuetype;
else if (atoi(apack->head.hook.hostname)>0)
xcdata.fno = atoi(apack->head.hook.hostname);
return(rtn);
}
else
{
DEBUG_RUNTIME_MSGOUT("ExtCall中间收到了非MT_PUSHDATA应答包，属于程序错误!");
rtn = 0; // 继续读取数据，以便接收到正确的MT_PUSHDATA应答包
}
}
else if (rtn==0)
{
return(-2); // 等待应答数据超时，即自从向外发送了请求后，在acktime+1秒内没有接收到应答数据
}
}
return(-1); // 其他各种通讯方面的错误
}
bool CSvrLink::CheckProcCancel()
{
int rtn;
MSGBUF *pmb;
unsigned char *rframe;
rtn = RecvMsg(0);
if (rtn>=(int)(sizeof(MSGHEAD)))
{
pmb = GetRecvMsg();
if (pmb->head.msgtype==MT_CMDCANCEL)
{
rframe = (unsigned char *)pmb->data;
if (rframe[0]==iGRFrame)
return(true);
}
}
return(false);
}
/*
* return number of bytes received, negative if error
*/
int32_t RecvMsg(zmq::socket_t &sock, int32_t &cid,
boost::shared_array<uint8_t> &data, bool *_more){
zmq::message_t msgt;
try{
sock.recv(&msgt);
}catch(zmq::error_t &e){
LOG(ERROR) << "RecvMsg error = " << e.what();
return -1;
}
size_t len = msgt.size();
if(len != sizeof(int32_t)){
LOG(ERROR) << "len != sizeof(int32_t)";
return -1;
}
cid = *((int32_t *) msgt.data());
return RecvMsg(sock, data, _more);
}
// 0 for received nothing
int32_t RecvMsgAsync(zmq::socket_t &sock, int32_t &cid,
boost::shared_array<uint8_t> &data, bool *_more){
zmq::message_t msgt;
int nbytes;
try{
nbytes = sock.recv(&msgt, ZMQ_DONTWAIT);
}catch(zmq::error_t &e){
return -1;
}
if(nbytes == 0){
if(zmq_errno() == EAGAIN)
return 0;
else
return -1;
}
size_t len = msgt.size();
if(len != sizeof(int32_t)) return -1;
cid = *((int32_t *) msgt.data());
return RecvMsg(sock, data, _more);
//it does not matter to use recv_msg_async or recv_msg
}
// 函数名: CSvrLink::SMLockCmd
// 编程 : 陈永华 2005-7-6 14:58:52
// 描述 : 这仅仅为了加解锁的命令内部调用，来简化程序
// 返回 : int
// 参数 : int smh
// 参数 : int lockmode
int CSvrLink::SMLockCmd(int smh, short lockmode)
{
int rtn;
if (smh<0)
return(-1000); // 共享内存块句柄错误，参见SMOpenBlock
smh = htonl(smh);
rtn = SendMsg(lockmode,sizeof(smh),&smh);
if (rtn<0) rtn -= 1000; // 属于严重错误，断开了与BCC的连接，退出
while (rtn==0)
{
rtn = RecvMsg(1000);
if (rtn>0)
{
MSGBUF *pmb = GetRecvMsg();
if (pmb->head.msgtype==lockmode)
{
/* ****** Updated by CHENYH at 2006-7-5 16:27:38 ******
rtn = ntohl(*(int *)pmb->data);
*******************************************************/
memcpy(&rtn,pmb->data,sizeof(rtn));
rtn = ntohl(rtn);
return(rtn);
}
else rtn = 0; // 继续
}
else if (rtn==0)
{
// 继续，比如锁等待
}
else
{
// 接收时候出错了
rtn -= 100;
}
}
return(rtn);
}
// 函数名: CSvrLink::SMInterlockedAdd
// 编程 : 陈永华 2005-7-6 11:08:58
// 描述 : 在共享内存块中指定的位置作为整数进行独占加法运算
// 返回 : int 返回独占加法运算后的值。
// 为0x80000000，可能属于系统或参数错误；
// 为0x80000001，则可能属于参数错误；
// 但不建议用这个作为判断
// 参数 : int smh：[IN] 共享内存块句柄，参见SMOpenBlock返回
// 参数 : unsigned int offset：[IN] 数据的偏移位置
// 参数 : int increment：[IN] 增量参数
int CSvrLink::SMInterlockedAdd(int smh, unsigned int offset, int increment)
{
unsigned char sbuf[MAXMSG];
RP_SMINTADD *pia;
int rtn;
if (smh<0)
return(SMIA_BADP); // 共享内存块句柄错误，参见SMOpenBlock
pia = (RP_SMINTADD *)sbuf;
pia->handle = htonl(smh);
pia->offset = htonl(offset);
pia->increment = htonl(increment);
rtn = SendMsg(MT_SMINTADD,sizeof(RP_SMINTADD),sbuf);
if (rtn<0) rtn = SMIA_ERR;
while (rtn==0)
{
// 发送成功：
rtn = RecvMsg(1000); // 1秒内应该该有结果了
if (rtn>0)
{
// 收到结果：
MSGBUF *pmb = GetRecvMsg();
if (pmb->head.msgtype==MT_SMINTADD)
{
// 收到的即为处理返回的值：
/* ****** Updated by CHENYH at 2006-7-5 16:27:38 ******
rtn = ntohl(*(int *)pmb->data);
*******************************************************/
memcpy(&rtn,pmb->data,sizeof(rtn));
rtn = ntohl(rtn);
return(rtn);
}
else rtn = 0; // 继续等待对方的应答
}
else break;
}
return(SMIA_ERR);
}
//================================================================
int main(int argc,char *argv[])
{
// variable
char *ipaddr = argv[1];
char sendbuffer[FILEBUFFERSIZE];
char recvbuffer[FILEBUFFERSIZE];
struct sockaddr_in SockAddr;
int AddrLen = sizeof(SockAddr);
// initialize
// memset(ipaddr,0,sizeof(ipaddr));
// 與server端連線
if (argc < 2) {
printf("%s serverip\n",argv[0]);
return 0;
}
ServerSock = ConnectToServer(ipaddr);
printf("waiting for welcome....\n");
while(1) {
// 由使用者輸入字串
printf("Please input string:\n");
fgets(sendbuffer,FILEBUFFERSIZE,stdin);
if (strncmp(sendbuffer,"exit\n",strlen("exit\n"))==0)
{
break;
}
SendMsg(ServerSock,sendbuffer);
memset(recvbuffer,0,FILEBUFFERSIZE);
// 等待server傳回"ok"字串,表示server確實有接收到client傳送過去的字串,如此一來,client才可以再傳送字串
RecvMsg(ServerSock,recvbuffer);
}
printf("#end#\n");
return 0;
}
HI_VOID *sw_HIFB_REFRESH(void *pData)
{
HI_S32 s32Ret = HI_SUCCESS;
HIFB_LAYER_INFO_S stLayerInfo = {0};
HIFB_BUFFER_S stCanvasBuf;
HI_U16 *pBuf;
HI_U32 x, y;
HI_BOOL Show;
HI_BOOL bCompress = HI_TRUE;
HIFB_POINT_S stPoint = {0};
struct fb_var_screeninfo stVarInfo;
char file[12] = "/dev/fb0";
HI_U32 maxW,maxH;
PTHREAD_HIFB_sw_INFO *pstInfo;
pstInfo = (PTHREAD_HIFB_sw_INFO *)pData;
HIFB_COLORKEY_S stColorKey;
switch (pstInfo->layer)
{
case 0 :
strcpy(file, "/dev/fb0");
break;
case 1 :
strcpy(file, "/dev/fb1");
break;
case 2 :
strcpy(file, "/dev/fb2");
break;
case 3 :
strcpy(file, "/dev/fb3");
break;
case 4 :
strcpy(file, "/dev/fb4");
break;
default:
strcpy(file, "/dev/fb0");
break;
}
pstInfo->fd = open(file, O_RDWR, 0);
if (pstInfo->fd < 0)
{
printf("open %s failed!\n",file);
return HI_NULL;
}
if (pstInfo->layer == HIFB_LAYER_0 )
{
if (ioctl(pstInfo->fd, FBIOPUT_COMPRESSION_HIFB, &bCompress) < 0)
{
printf("FBIOPUT_COMPRESSION_HIFB failed!\n");
close(pstInfo->fd);
return HI_NULL;
}
}
stColorKey.bKeyEnable = HI_TRUE;
stColorKey.u32Key = 0x0;
if (ioctl(pstInfo->fd, FBIOPUT_COLORKEY_HIFB, &stColorKey) < 0)
{
printf("FBIOPUT_COLORKEY_HIFB!\n");
close(pstInfo->fd);
return HI_NULL;
}
s32Ret = ioctl(pstInfo->fd, FBIOGET_VSCREENINFO, &stVarInfo);
if (s32Ret < 0)
{
printf("GET_VSCREENINFO failed!\n");
return HI_NULL;
}
if (ioctl(pstInfo->fd, FBIOPUT_SCREEN_ORIGIN_HIFB, &stPoint) < 0)
{
printf("set screen original show position failed!\n");
return HI_NULL;
}
maxW = 1280;
maxH = 720;
stVarInfo.xres = stVarInfo.xres_virtual = maxW;
stVarInfo.yres = stVarInfo.yres_virtual = maxH;
setRelolution(maxW,maxH);
s32Ret = ioctl(pstInfo->fd, FBIOPUT_VSCREENINFO, &stVarInfo);
if (s32Ret < 0)
{
printf("PUT_VSCREENINFO failed!\n");
return HI_NULL;
}
switch (pstInfo->ctrlkey)
{
case 0 :
{
stLayerInfo.BufMode = HIFB_LAYER_BUF_ONE;
stLayerInfo.u32Mask = HIFB_LAYERMASK_BUFMODE;
break;
}
case 1 :
{
stLayerInfo.BufMode = HIFB_LAYER_BUF_DOUBLE;
stLayerInfo.u32Mask = HIFB_LAYERMASK_BUFMODE;
break;
}
default:
{
stLayerInfo.BufMode = HIFB_LAYER_BUF_NONE;
stLayerInfo.u32Mask = HIFB_LAYERMASK_BUFMODE;
}
}
s32Ret = ioctl(pstInfo->fd, FBIOPUT_LAYER_INFO, &stLayerInfo);
if (s32Ret < 0)
{
printf("PUT_LAYER_INFO failed!\n");
return HI_NULL;
}
Show = HI_TRUE;
if (ioctl(pstInfo->fd, FBIOPUT_SHOW_HIFB, &Show) < 0)
{
printf("FBIOPUT_SHOW_HIFB failed!\n");
return HI_NULL;
}
if (HI_FAILURE == HI_MPI_SYS_MmzAlloc(&(stCanvasBuf.stCanvas.u32PhyAddr), ((void**)&pBuf),
NULL, NULL, maxW*maxH*2))
{
printf("allocate memory (maxW*maxH*2 bytes) failed\n");
return HI_NULL;
}
stCanvasBuf.stCanvas.u32Height = maxH;
stCanvasBuf.stCanvas.u32Width = maxW;
stCanvasBuf.stCanvas.u32Pitch = maxW*2;
stCanvasBuf.stCanvas.enFmt = HIFB_FMT_ARGB1555;
memset(pBuf, 0x00, stCanvasBuf.stCanvas.u32Pitch*stCanvasBuf.stCanvas.u32Height);
gdc.tcClear=0x00;
gdc.pWinFb->hFB=pstInfo->fd;
gdc.pWinFb->pMappedAddr=pBuf;
gdc.pWinFb->pPhyAddr=stCanvasBuf.stCanvas.u32PhyAddr;
gdc.pSzWin.nW=maxW;
gdc.pSzWin.nH=maxH;
windowInit();
CreateMsgQueue(&gdc.nMsgid,20);
while(1)
{
pWINDOW_S pOsd=getOSDWnd();
MSG msg={WIN_FLASH_ALL,0};
SendMsg(gdc.nMsgid,msg);
while(1)
{
RecvMsg(gdc.nMsgid,&msg,TRUE);
switch(msg.message)
{
case WIN_FLASH_ALL:
windowFlush();
stCanvasBuf.UpdateRect.x = 0;
stCanvasBuf.UpdateRect.y = 0;
stCanvasBuf.UpdateRect.w = maxW;
stCanvasBuf.UpdateRect.h = maxH;
s32Ret = ioctl(pstInfo->fd, FBIO_REFRESH, &stCanvasBuf);
if (s32Ret < 0)
{
printf("REFRESH failed!\n");
}
break;
case WIN_WIN_FLASH:
case WIN_FLASH_AREA:
case WIN_CTRL_FLASH:
break;
}
}
}
return HI_NULL;
}
void
HandleReaderMsg(ForkDesc *desc)
{
int r;
int recv_fd;
DnsRes dres;
if ((r = RecvMsg(desc->d_Fd, &recv_fd, &dres)) == sizeof(DnsRes)) {
if (recv_fd >= MAXFDS) {
logit(LOG_WARNING, "fd too large %d/%d, increase MAXFDS for select. Closing fd", recv_fd, MAXFDS);
/*
* Tell the main server that we are done with the connection
*/
fcntl(TFd, F_SETFL, 0);
SendMsg(TFd, recv_fd, &dres);
fcntl(TFd, F_SETFL, O_NONBLOCK);
} else if (recv_fd >= 0) {
ForkDesc *ndesc;
Connection *conn;
char vsbuf[11];
char hsbuf[31];
if (ReadAccessCache() == 1) {
ScanThreads(THREAD_NNTP, UpdateAuthDetails);
ScanThreads(THREAD_SPOOL, UpdateAuthDetails);
ScanThreads(THREAD_READER, UpdateAuthDetails);
ScanThreads(THREAD_SPOOL, UpdateAuthDetails);
ScanThreads(THREAD_FEEDER, UpdateAuthDetails);
ClearOldAccessMap();
}
SetAuthDetails(&dres, dres.dr_ReaderName);
ndesc = AddThread("client", recv_fd, -1, THREAD_NNTP, makeReaderSlot(), 0);
++NumReaders;
if (DebugOpt)
printf("add thread fd=%d\n", recv_fd);
FD_SET(ndesc->d_Fd, &WFds); /* will cause immediate effect */
conn = InitConnection(ndesc, &dres);
if (conn->co_Auth.dr_Flags & DF_FEED)
conn->co_Flags |= COF_SERVER;
snprintf(vsbuf, sizeof(vsbuf), "%s", conn->co_Auth.dr_VServerDef->vs_Name);
snprintf(hsbuf, sizeof(hsbuf), "%s%s%s%s%s",
*conn->co_Auth.dr_AuthUser ? conn->co_Auth.dr_AuthUser : "",
*conn->co_Auth.dr_AuthUser ? "/" : "",
*conn->co_Auth.dr_IdentUser ? conn->co_Auth.dr_IdentUser : "",
*conn->co_Auth.dr_IdentUser ? "@" : "",
conn->co_Auth.dr_Host);
RTStatusBase(conn->co_Desc->d_Slot, "ACTV %-10s %-30s", vsbuf, hsbuf);
StatusUpdate(conn, "(startup)");
if (conn->co_Auth.dr_ResultFlags & DR_REQUIRE_DNS)
NNAuthDone(conn);
else
NNWriteHello(conn);
} else {
if (DebugOpt)
printf("recvmsg(): EOF1\n");
DelThread(desc);
TerminatePending = 1;
}
}
/*
* If recv error, check errno. If temporary error,
* leave r negative (select loop). Set r = 0 to
* terminate.
*/
if (r != sizeof(DnsRes) && r != -1) {
if (DebugOpt)
printf("recvmsg(): Bad size read from RecvMsg\n");
}
if (r < 0) {
if (errno != EINTR &&
errno != EWOULDBLOCK &&
errno != EAGAIN
) {
r = 0;
}
}
/*
* EOF (or error)
*/
if (r == 0) {
if (DebugOpt)
printf("recvmsg(): EOF/error from parent %s\n", strerror(errno));
DelThread(desc);
TerminatePending = 1;
}
}
int CSvrLink::ExtCall(int sourceno, int destno, int funcno, int batchno, int acktime, void *rdata, int rdlen, char *abuf, int &alen)
{
int rtn;
char szmsg[256];
ST_PACKHEAD phead;
xcdata.sno = sourceno;
xcdata.dno = destno;
xcdata.fno = funcno;
xcdata.bno = batchno;
DecodeHead((unsigned char *)rdata,rdlen,&phead,szmsg);
phead.userdata = batchno;
ModifyHead(&phead,(unsigned char *)rdata);
if (acktime<=0)
{
acktime = 5; // 缺省为5秒钟内得到应答，否则作为失败处理。。。以防止业务部分调用错误导致整个BUNIT处理失败或挂起
}
rtn = PushData(sourceno,destno,funcno,batchno,PM_ANSWER,acktime,rdata,rdlen);
while (rtn==0)
{
rtn = RecvMsg(acktime*1000+1000);
if (rtn>0)
{
MSGBUF *pmb = GetRecvMsg();
if (pmb->head.msgtype==MT_PUSHDATA)
{
// 有应答数据返回：
alen = pmb->head.len;
memcpy(abuf,pmb->data,alen);
DecodeHead((unsigned char *)abuf,alen,&(xcdata.ahead),szmsg);
// 为了正确提取外调功能的后续包（尤其对BCC能够支持并行多应用服务器架构），则采用
if (xcdata.ahead.hook.queuename[0]>='0' && xcdata.ahead.hook.queuename[0]<='9'
&& xcdata.ahead.hook.queuetype>0)
{
// 属于KSBCC模式的XPACK协议：
xcdata.fno = xcdata.ahead.hook.queuetype;
// 包括能够处理被目标点转发后处理的请求
if (0==xcdata.ahead.hook.hostname[0])
{
int dno = atoi(xcdata.ahead.hook.hostname+1);
if (dno>0)
{
xcdata.dno = dno;
}
}
// m_bBCCADP: 2006-3-17 17:14:21
else if (0!=xcdata.ahead.hook.hostname[10])
{
int dno = atoi(xcdata.ahead.hook.hostname+10);
if (dno>0)
{
xcdata.dno = dno;
}
}
//////////////////////////////////////////////////////////////////////////
}
return(rtn);
}
else
{
DEBUG_RUNTIME_MSGOUT("ExtCall中间收到了非MT_PUSHDATA应答包，属于程序错误!");
rtn = 0; // 继续读取数据，以便接收到正确的MT_PUSHDATA应答包
}
}
else if (rtn==0)
{
return(-2); // 等待应答数据超时，即自从向外发送了请求后，在acktime+1秒内没有接收到应答数据
}
}
return(-1); // 其他各种通讯方面的错误
}
int CSvrLink::Processing(ST_BUNIT *pBUnit)
{
int rtn;
MSGBUF *pmb;
RP_REQUEST rp;
if (linksock.IsFree())
return(0);
rp.iGRFrame = iGRFrame;
rp.iLastReqType = htonl(iLastReqType);
rp.iLastRetCode = htonl(iLastRetCode);
rtn = SendMsg(MT_GETREQ,sizeof(rp),&rp);
if (rtn!=0)
{
// 连接出现问题了：或被BCC关闭了
return(-1);
}
GETNEXTMSG:
rtn = RecvMsg(pBUnit->iHBInterval);
if (rtn>=(int)(sizeof(MSGHEAD)))
{
pmb = GetRecvMsg();
switch (pmb->head.msgtype)
{
case MT_LINKBEGIN:
// Update some variables:
if (pmb->head.len>=sizeof(AP_LINKBEGIN))
{
AP_LINKBEGIN *pap;
pap = (AP_LINKBEGIN *)(pmb->data);
svr_hs1 = pap->bc1;
iThisProcID = ntohl(pap->bu_number);
}
break;
case EXITMSGTYPE:
Close();
bExit = true;
break;
case WRITEAPPINFO:
(*pWriteAppInfo)(bccBFuncNo,bccID); // 在主框架程序部分
break;
case MT_GETREQ:
// OK,have new request to process
if (pmb->head.len>=sizeof(AP_REQUEST)+sizeof(ST_PACKHEAD))
{
AP_REQUEST *prp = (AP_REQUEST *)(pmb->data);
if (prp->iGRFrame==iGRFrame)
{
CallBPFunction(pmb);
iGRFrame++;
}
}
break;
/* ****** Updated by CHENYH at 2005-10-24 14:29:13 ****** */
// 当BU用CheckLink()发送MT_TESTLINK心跳检查的时候，BCC给BU反馈一个心跳检查应答，
// 当BU用CheckLink()命令的时候，应该用tc2_tc1(GetTickCount(),m_lastrcvtick)与pBUnit->iHBInterval×2来比较
// BCC与BU在不稳定网络下，链路是否正常的。
case MT_TESTLINK:
goto GETNEXTMSG; // 仅仅作为当BU给BCC发送MT_TESTLINK心跳检查时候，BCC给BU的心跳检查应答
break;
/*******************************************************/
default:
break;
}
}
return(rtn);
}
void ServiceMain(int argc, char **argv)
{
DWORD error;
ServiceStatus.dwServiceType = SERVICE_WIN32;
ServiceStatus.dwCurrentState = SERVICE_START_PENDING;
ServiceStatus.dwControlsAccepted =
SERVICE_ACCEPT_STOP |
SERVICE_ACCEPT_SHUTDOWN;
ServiceStatus.dwWin32ExitCode = 0;
ServiceStatus.dwServiceSpecificExitCode = 0;
ServiceStatus.dwCheckPoint = 0;
ServiceStatus.dwWaitHint = 0;
hStatus = RegisterServiceCtrlHandler(SERVICE_NAME, (LPHANDLER_FUNCTION)ControlHandler);
if(hStatus == (SERVICE_STATUS_HANDLE)0)
{
return;
}
if(InitSerivce() != 0)
{
goto STOPSERVER;
}
error = ReadStatus();
if(error == -1)
{
if(GetNextFile() != 0 ||
PlayMusic() != 0)
{
goto STOPSERVER;
}
}
else
{
if(pauseFlag == FALSE && stopFlag == FALSE)
{
if(PlayMusic() != 0)
{
goto STOPSERVER;
}
}
else
{
if(GetMusicStatus() != 0)
{
goto STOPSERVER;
}
}
}
ServiceStatus.dwCurrentState = SERVICE_RUNNING;
SetServiceStatus(hStatus, &ServiceStatus);
while(ServiceStatus.dwCurrentState == SERVICE_RUNNING)
{
if(RecvMsg() != 0)
{
goto STOPSERVER;
}
if(playingFlag == FALSE && stopFlag == FALSE && pauseFlag == FALSE)
{
StopMusic();
if(GetNextFile() != 0 ||
PlayMusic() != 0)
{
goto STOPSERVER;
}
}
}
STOPSERVER:
ServiceStatus.dwCurrentState = SERVICE_STOPPED;
ServiceStatus.dwWin32ExitCode = -1;
SetServiceStatus(hStatus, &ServiceStatus);
return;
}
ssize_t TcpTransport::RecvData(std::list<std::string*>& outDataList)
{
ssize_t ret = RecvMsg();
ProcessData(outDataList);
return ret;
}
BOOL CJaxerConnection::RecevMsgIfAny(char** msg)
{
// Return FALSE if failure,
// Otherwise *msg will not be null
// if there is msg
int rc;
*msg = 0;
u_long iMode = 1; //Non Blocking
if (ioctlsocket(m_socket, FIONBIO, &iMode))
{
DWORD err = WSAGetLastError();
GetJaxerLog().Log(eERROR, "RecevMsgIfAny: ioctlsocket turn on non-block failed: err = %d", err);
return FALSE;
}
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = 0;
fd_set fdread;
FD_ZERO(&fdread);
FD_SET(m_socket, &fdread);
rc = select(1 + (int)m_socket, &fdread, NULL, NULL, &tv);
if (rc < 0)
{
GetJaxerLog().Log(eERROR, "RecevMsgIfAny: socket select failed: err = %d", WSAGetLastError());
return FALSE;
}
/* turn off non-blocking */
iMode = 0;
if (ioctlsocket(m_socket, FIONBIO, &iMode))
{
DWORD err = WSAGetLastError();
GetJaxerLog().Log(eERROR, "RecevMsgIfAny: ioctlsocket turn off non-block failed: err = %d", err);
return FALSE;
}
/* return if nothing */
if (rc == 0)
return TRUE;
/*
* Since we have only one socket, we know we have data for reading if we are here.
* read a message
*/
if (! RecvMsg(msg))
{
GetJaxerLog().Log(eERROR, "RecevMsgIfAny: RecvMsg (hdr or post) failed");
return FALSE;
}
return TRUE;
}
