C++ SocketClient类代码示例

void SocketListener1::sendData(const void *data, int len) {
  SocketClientCollection safeList;

  /* Add all active clients to the safe list first */
  safeList.clear();
  pthread_mutex_lock(&mClientsLock);
  SocketClientCollection::iterator i;

  for (i = mClients->begin(); i != mClients->end(); ++i) {
    SocketClient* c = *i;
    c->incRef();
    safeList.push_back(c);
  }
  pthread_mutex_unlock(&mClientsLock);

  while (!safeList.empty()) {
    /* Pop the first item from the list */
    i = safeList.begin();
    SocketClient* c = *i;
    safeList.erase(i);
    if (c->sendData(data, len)) {
      ALOGW("Error sending data (%s)", strerror(errno));
    }
    c->decRef();
    // Release socket client on socket disconnect
    if (errno == EPIPE) {
      ALOGW("Socket disconnect; closing");
      release(c, false);
    }
  }
}

bool HttpServer::methodPost(const SocketClient &client) {
	std::string content;
	if (StringConverter::getContentFrom(client.getMessage(), content)) {
		std::string file;
		if (StringConverter::getRequestedFile(client.getMessage(), file)) {
			if (file.compare("/data.xml") == 0) {
				// not used yet
			} else if (file.compare("/streams.xml") == 0) {
				_streams.fromXML(content);
			} else if (file.compare("/config.xml") == 0) {
				_properties.fromXML(content);
#ifdef LIBDVBCSA
			} else if (file.compare("/dvbapi.xml") == 0) {
				_streams.getDecrypt()->fromXML(content);
#endif
			}
		}
	}
	// setup reply
	std::string htmlBody;
	getHtmlBodyWithContent(htmlBody, HTML_NO_RESPONSE, "", CONTENT_TYPE_HTML, 0, 0);

	// send 'htmlBody' to client
	if (send(client.getFD(), htmlBody.c_str(), htmlBody.size(), 0) == -1) {
		PERROR("send htmlBody");
		return false;
	}
	return true;
}

inline
int
SocketRegistry<T>::syncPerformReceive(char * host,
                                      T & t,
                                      Uint32 timeOutMillis) {
    char buf[255] ; //temp. just for testing. must fix better
    struct timeval timeout;
    timeout.tv_sec  = timeOutMillis / 1000;
    timeout.tv_usec = (timeOutMillis % 1000) * 1000;
    int reply;
    SocketClient * sc;
    for(Uint32 i=0; i < m_nSocketClients; i++) {
        sc = m_socketClients[i];
        if(strcmp(sc->gethostname(), remotehost)==0) {
            if(sc->isConnected()) {
                FD_ZERO(&tcpReadset);
                reply = select(sc->getSocket(), &tcpReadset, 0, 0, &timeout);
                if(reply > 0) {
                    return t->runSession(sc->getSocket(), t);
                }
            }

        }
    }
    return 0;
}

void SocketListener::sendBroadcast(int code, const char *msg, bool addErrno) {
    SocketClientCollection safeList;

    /* Add all active clients to the safe list first */
    safeList.clear();
    pthread_mutex_lock(&mClientsLock);
    SocketClientCollection::iterator i;

    for (i = mClients->begin(); i != mClients->end(); ++i) {
        SocketClient* c = *i;
        c->incRef();
        safeList.push_back(c);
    }
    pthread_mutex_unlock(&mClientsLock);

    while (!safeList.empty()) {
        /* Pop the first item from the list */
        i = safeList.begin();
        SocketClient* c = *i;
        safeList.erase(i);
        // broadcasts are unsolicited and should not include a cmd number
        if (c->sendMsg(code, msg, addErrno, false)) {
            SLOGW("Error sending broadcast (%s)", strerror(errno));
        }
        c->decRef();
    }
}

/**< 跟第三方系统进行通信 */
int CTradeBase::DoSendAndRcv(unsigned char *ReqBuf, int ReqLen,unsigned char *RepBuf, int *RepLen, int TimeOut,char* errDesc)
{
    trace_log(DBG, "SndBuf len:%d",ReqLen);
    trace_mem(ReqBuf, ReqLen);
    SocketClient client;
    return client.SendToHost(ReqBuf,ReqLen,RepBuf,*RepLen,g_Cfg.CupHost.cIp,g_Cfg.CupHost.iPort,40,errDesc);
}

void SocketClient::dataCallback(int, unsigned int flags, void* userData)
{
    SocketClient* client = reinterpret_cast<SocketClient*>(userData);
    if (flags & EventLoop::Read)
        client->readMore();
    if (flags & EventLoop::Write)
        client->writeMore();
}

DWORD WINAPI ClientIOCP::WorkerThread(LPVOID lpObject)
{
	SocketClient client;
	char* reply;

	int res = client.Connect(8085);
	client.Send("This is a test\n", reply);
	return 1;
}

inline
int 
SocketRegistry<T>::pollSocketClients(Uint32 timeOutMillis) {



  // Return directly if there are no TCP transporters configured
  if (m_nSocketClients == 0){
    tcpReadSelectReply = 0;
    return 0;
  }
  struct timeval timeout;
  timeout.tv_sec  = timeOutMillis / 1000;
  timeout.tv_usec = (timeOutMillis % 1000) * 1000;


  NDB_SOCKET_TYPE maxSocketValue = 0;
  
  // Needed for TCP/IP connections
  // The read- and writeset are used by select
  
  FD_ZERO(&tcpReadset);

  // Prepare for sending and receiving
  for (Uint32 i = 0; i < m_nSocketClients; i++) {
    SocketClient * t = m_socketClients[i];
    
    // If the socketclient is connected
    if (t->isConnected()) {
      
      const NDB_SOCKET_TYPE socket = t->getSocket();
      // Find the highest socket value. It will be used by select
      if (socket > maxSocketValue)
	maxSocketValue = socket;
      
      // Put the connected transporters in the socket read-set 
      FD_SET(socket, &tcpReadset);
    }
  }
  
  // The highest socket value plus one
  maxSocketValue++; 
  
  tcpReadSelectReply = select(maxSocketValue, &tcpReadset, 0, 0, &timeout);  
#ifdef NDB_WIN32
  if(tcpReadSelectReply == SOCKET_ERROR)
  {
    NdbSleep_MilliSleep(timeOutMillis);
  }
#endif

  return tcpReadSelectReply;

}

/**< 跟第三方系统进行通信 */
int CTradeBase::DoSendAndRcv(unsigned char *ReqBuf, int ReqLen,unsigned char *RepBuf, int *RepLen, int TimeOut,char* errDesc)
{
    trace_log(DBG, "SndBuf len:%d",ReqLen);
    trace_mem(ReqBuf, ReqLen);
#ifndef USE_LONG_CONN
    SocketClient client;
    return client.SendToHost(ReqBuf,ReqLen,RepBuf,*RepLen,g_Cfg.CupHost[0].Host,g_Cfg.CupHost[0].Port,40,errDesc);
#else
	return 0;
#endif
}

int _tmain(int argc, _TCHAR* argv[])
{
	SocketClient so = SocketClient("192.168.0.179");
	so.sendTo("Hello from C++  111");
	so.sendTo("Hello from C++  222");
	so.~SocketClient();

	/*WSAData data;
	SOCKET sock;
	struct sockaddr_in si_other;
	const std::string address = "192.168.0.179";
	int slen = sizeof(si_other);
	char message[512] = "Hello World Java, I am a C++ Client Socket";

	int ret = WSAStartup(MAKEWORD(2, 2), &data);
	if (ret != 0) {
		printf("Error WSAStartup failed: " + WSAGetLastError());
		WSACleanup();
	}

	sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
	if (sock == INVALID_SOCKET) {
		printf("Error opening socket: " + WSAGetLastError());
	}

	memset((char *)&si_other, 0, sizeof(si_other));
	si_other.sin_family = AF_INET;
	si_other.sin_port = htons(8881);
	si_other.sin_addr.S_un.S_addr = inet_addr(address.c_str());
	
	std::stringstream sstm;
	for (int i = 0; i < 10; i++) {
		sstm << "Attemp #" << i << " - Sending:" << message << "\n";
		printf(sstm.str().c_str());
		ret = sendto(sock, message, strlen(message), 0, (struct sockaddr *) &si_other, slen);
		if (ret < 0) {
			sstm << "Failed Sending:" << WSAGetLastError();
		}
		sstm.str("");
	}

	printf("\n *** End ***");
	std::getchar();
	exit(0);

	closesocket(sock);
	WSACleanup();  */

	return 0;
}

bool
SocketRegistry<T>::reconnect(const char * host) {
    for(Uint32 i=0; i < m_nSocketClients; i++) {
        SocketClient * socketClient = m_socketClients[i];
        if(strcmp(socketClient->gethostname(), host)==0) {
            if(!socketClient->isConnected()) {
                if(socketClient->openSocket() > 0)
                    return true;
                else return false;
            }
        }
    }
    return false;
}

inline
bool 
SocketRegistry<T>::removeSocketClient(const char * host){
  for(Uint32 i=0; i < m_nSocketClients; i++) {
    SocketClient * socketClient = m_socketClients[i];
    if(strcmp(socketClient->gethostname(), host)==0) {
      if(!socketClient->isConnected()) {
	if(socketClient->closeSocket() > 0) {
	  delete socketClient;
	  return true;
	}
	else return false;
      }
    }
  }
  return false;
}

void sendFacialExpressionAnimation(SocketClient& sock, EmoStateHandle eState) {

	std::ostringstream output;

    IEE_FacialExpressionAlgo_t upperFaceType =
                            IS_FacialExpressionGetUpperFaceAction(eState);
    IEE_FacialExpressionAlgo_t lowerFaceType =
                            IS_FacialExpressionGetLowerFaceAction(eState);

	float upperFaceAmp = IS_FacialExpressionGetUpperFaceActionPower(eState);
	float lowerFaceAmp = IS_FacialExpressionGetLowerFaceActionPower(eState);

	if (IS_FacialExpressionIsBlink(eState)) {
		output << "B,";
	}

	if (IS_FacialExpressionIsLeftWink(eState)) {
		output << "l,";
	}

	if (IS_FacialExpressionIsRightWink(eState)) {
		output << "r,";
	}


	if (upperFaceAmp > 0.0) {
		switch (upperFaceType) {
			case FE_SURPRISE:	output << "b";	break;
			case FE_FROWN:    output << "f";  break;
			default:			break;
		}
		output << numberToString(static_cast<int>(upperFaceAmp*100.0f)) << ",";
	}

	if (lowerFaceAmp > 0.0) {
		switch (lowerFaceType) {
			case FE_CLENCH:	output << "G";	break;
			case FE_SMILE:		output << "S";	break;
			default:			break;
		}
		output << numberToString(static_cast<int>(lowerFaceAmp*100.0f)) << ",";
	}

	std::string outString = output.str();

	// Remove the last comma
	if (outString.length()) {
		outString.resize(outString.length()-1);
	}

	if (!outString.length()) {
		outString = std::string("neutral");
	}

	sock.SendBytes(outString);
}

/**************************************************************
函数名称: GetDataFromHsm
函数功能: 连接加密机从其获取数据
入口参数: pMsgBuffer[in/out]:发送或返回的数据中的MSG
           iLen[in/out]:发送或返回数据的长度
相关调用:
返 回 值: true成功， false失败
**************************************************************/
bool EnCryptComm::GetDataFromHsm(unsigned char *pMsgBuffer, unsigned & iLen)
{
    unsigned char cmd = pMsgBuffer[0], Buffer[1024]={0};
    unsigned sLen;//发送数据长度
    sLen = iLen + 7;
    memcpy(Buffer, &sLen, 2);//LC
    Buffer[2]=0xF1;//INS
    Buffer[3]=0;//SEQ
    //CR默认为0
    memcpy(&Buffer[6], pMsgBuffer, iLen);//MSG
    Buffer[sLen-1] = CalcSum(Buffer, sLen - 1);//CRC
    char errDesc[512]={0};
    unsigned char cRecBuf[1024]={0};
    int recLen=0;
    SocketClient client;
    int iErrorCode=client.SendToHost(Buffer,sLen,cRecBuf,recLen,g_Cfg.EncHost.Host, g_Cfg.EncHost.Port,20,errDesc);
    if(0==iErrorCode)
    {
    	trace_log(DBG, "recv from enchost");
		trace_mem(cRecBuf, recLen);
        if(cRecBuf[recLen-1] == CalcSum(cRecBuf, recLen - 1) && cRecBuf[6] == cmd && cRecBuf[8] == CMD_OK)
        {//校验值正确,与原命令字相同,返回码为成功
            if(memcmp(pMsgBuffer+2, cRecBuf+9, LEN_MERCHNO+LEN_TERMINO)!=0)//+LEN_TERMINO
            {//比较商户号与终端号
                trace_log(DBG, "The return data from encryptor is not match!!");
                return false;
            }
            memcpy(pMsgBuffer, cRecBuf+6, recLen-7);//去掉LC,INS,SEQ,CR,CRC
            iLen = recLen-7;
            trace_log(DBG,"GetDataFromHsm->iLen=%d",iLen);
            return true;
        }
        else
        {
            trace_log(ERR, "GetDataFromHsm else CalcSum  %d", recLen);
            return false ;
        }
    }else{
        trace_log(ERR,errDesc);
        return false;
    }
}

void *SocketClient::ReceiveThread(void *para) {
	SocketClient *socketClient = (SocketClient *) para;
	int res;
	while (1) {
		res = recv(socketClient->clientSockFd, socketClient->recvMessage, BUFFER_SIZE, 0);
		if (res == 0) {
			close(socketClient->clientSockFd);
			socketClient->clientSockFd = -1;
			socketClient->pUpdateStauts(Disconnected);
			break;
		}else if(res > 0){
			socketClient->pUpdateMessage(socketClient->recvMessage, res);
		}else{
			perror("receive error");
		}

	}
	printf("Server Closed\n");
	return 0;
}