示例#1
0
void ServerWorker::_processMessages()
{
    const qint64 headerSize( MessageHeader::serializedSize );

    if( _tcpSocket->bytesAvailable() >= headerSize )
        _receiveMessage();

    // Send all events
    foreach( const Event& evt, _events )
        _send( evt );
    _events.clear();

    _tcpSocket->flush();

    // Finish reading messages from the socket if connection closed
    if( _tcpSocket->state() != QAbstractSocket::ConnectedState )
    {
        while( _tcpSocket->bytesAvailable() >= headerSize )
            _receiveMessage();

        emit( connectionClosed( ));
    }
    else if( _tcpSocket->bytesAvailable() >= headerSize )
        emit _dataAvailable();
}
示例#2
0
void LMEConnection::_doRX()
{
	unsigned int bytesRead;
	int status = 1;

	_threadStartedEvent.set();

	unsigned char *rxBuffer = new unsigned char[_heci.GetBufferSize()];

	while (true) {
		bytesRead = (unsigned int)_receiveMessage(rxBuffer, _heci.GetBufferSize());

		if ((int)bytesRead < 0) {
			PRINT("Error receiving data from HECI\n");
			Deinit();
			break;
		}

		if (bytesRead == 0) {
			// ERROR
			continue;
		}

		PRINT("Received from LME %d bytes (msg type %02d)\n", bytesRead, rxBuffer[0]);

		if (!_checkMinMsgSize(rxBuffer, bytesRead)) {
			PRINT("Error receiving data from HECI\n");
			Deinit();
			break;
		}

		if (plugin.preprocess(rxBuffer, bytesRead) == LMS_DROPPED) {
			continue;
		}

		switch (rxBuffer[0]) {
		case APF_DISCONNECT:
			{
				LMEDisconnectMessage disconnectMessage(
				    (APF_DISCONNECT_REASON_CODE)ntohl(
					((APF_DISCONNECT_MESSAGE *)rxBuffer)->ReasonCode));

				_cb(_cbParam, &disconnectMessage, sizeof(disconnectMessage), &status);
			}
			break;

		case APF_SERVICE_REQUEST:
			{
				APF_SERVICE_REQUEST_MESSAGE *pMessage =
					(APF_SERVICE_REQUEST_MESSAGE *)rxBuffer;
				LMEServiceRequestMessage serviceRequestMessage;

				serviceRequestMessage.ServiceName.append(
					(char *)(pMessage->ServiceName),
					ntohl(pMessage->ServiceNameLength));

				_cb(_cbParam, &serviceRequestMessage, sizeof(serviceRequestMessage), &status);
			}
			break;

		case APF_USERAUTH_REQUEST:
			_apfUserAuthRequest(rxBuffer, bytesRead, &status);
			break;

		case APF_GLOBAL_REQUEST:
			_apfGlobalRequest(rxBuffer, bytesRead, &status);
			break;

		case APF_CHANNEL_OPEN:
			_apfChannelOpen(rxBuffer, bytesRead, &status);
			break;

		case APF_CHANNEL_OPEN_CONFIRMATION:
			{
				APF_CHANNEL_OPEN_CONFIRMATION_MESSAGE *pMessage =
				    (APF_CHANNEL_OPEN_CONFIRMATION_MESSAGE *)rxBuffer;
				LMEChannelOpenReplaySuccessMessage channelOpenReply;

				channelOpenReply.RecipientChannel = ntohl(pMessage->RecipientChannel);
				channelOpenReply.SenderChannel = ntohl(pMessage->SenderChannel);
				channelOpenReply.InitialWindow = ntohl(pMessage->InitialWindowSize);
				_cb(_cbParam, &channelOpenReply, sizeof(channelOpenReply), &status);
			}
			break;

		case APF_CHANNEL_OPEN_FAILURE:
			{
				APF_CHANNEL_OPEN_FAILURE_MESSAGE *pMessage =
				    (APF_CHANNEL_OPEN_FAILURE_MESSAGE *)rxBuffer;
				LMEChannelOpenReplayFailureMessage channelOpenReply;

				channelOpenReply.RecipientChannel = ntohl(pMessage->RecipientChannel);
				channelOpenReply.ReasonCode =
					(OPEN_FAILURE_REASON)(ntohl(pMessage->ReasonCode));
				_cb(_cbParam, &channelOpenReply, sizeof(channelOpenReply), &status);
			}
			break;

		case APF_CHANNEL_CLOSE:
			{
				APF_CHANNEL_CLOSE_MESSAGE *pMessage =
				    (APF_CHANNEL_CLOSE_MESSAGE *)rxBuffer;
				LMEChannelCloseMessage channelClose;

				channelClose.RecipientChannel = ntohl(pMessage->RecipientChannel);
				_cb(_cbParam, &channelClose, sizeof(channelClose), &status);
			}
			break;

		case APF_CHANNEL_DATA:
			{
				APF_CHANNEL_DATA_MESSAGE *pMessage =
				    (APF_CHANNEL_DATA_MESSAGE *)rxBuffer;
				LMEChannelDataMessage channelData(ntohl(pMessage->RecipientChannel),
								  ntohl(pMessage->DataLength),
								  pMessage->Data);
				_cb(_cbParam, &channelData, sizeof(channelData), &status);
			}
			break;

		case APF_CHANNEL_WINDOW_ADJUST:
			{
				APF_WINDOW_ADJUST_MESSAGE *pMessage =
				    (APF_WINDOW_ADJUST_MESSAGE *)rxBuffer;
				LMEChannelWindowAdjustMessage channelWindowAdjust;

				channelWindowAdjust.RecipientChannel = ntohl(pMessage->RecipientChannel);
				channelWindowAdjust.BytesToAdd = ntohl(pMessage->BytesToAdd);
				_cb(_cbParam, &channelWindowAdjust, sizeof(channelWindowAdjust), &status);
			}
			break;

		case APF_PROTOCOLVERSION:
			{
				APF_PROTOCOL_VERSION_MESSAGE *pMessage =
				    (APF_PROTOCOL_VERSION_MESSAGE *)rxBuffer;
				LMEProtocolVersionMessage protVersion;

				protVersion.MajorVersion = ntohl(pMessage->MajorVersion);
				protVersion.MinorVersion = ntohl(pMessage->MinorVersion);
				protVersion.TriggerReason =
					(APF_TRIGGER_REASON)ntohl(pMessage->TriggerReason);
				_cb(_cbParam, &protVersion, sizeof(protVersion), &status);
			}
			break;

		default:
			// Uknown request. Ignore
			break;
		}

		if (IsInitialized()) {
			plugin.postprocess(rxBuffer, bytesRead, status);
		}
	}

	if (rxBuffer != NULL) {
		delete[] rxBuffer;
	}
}