/***************************************************************************** * main *****************************************************************************/ int main(int i_argc, char* pa_argv[]) { int i_fd; uint8_t data[188]; dvbpsi_handle h_dvbpsi; int b_ok; if(i_argc != 2) return 1; i_fd = open(pa_argv[1], 0); h_dvbpsi = dvbpsi_AttachPAT(DumpPAT, NULL); b_ok = ReadPacket(i_fd, data); while(b_ok) { uint16_t i_pid = ((uint16_t)(data[1] & 0x1f) << 8) + data[2]; if(i_pid == 0x0) dvbpsi_PushPacket(h_dvbpsi, data); b_ok = ReadPacket(i_fd, data); } dvbpsi_DetachPAT(h_dvbpsi); return 0; }
void G2Node::OnPacketHeader(const bs::error_code& err) { if(closed_) return; if(!err) { assert(g2buffer_.size() > 0); rawPacket_.insert(rawPacket_.end(), g2buffer_.begin(), g2buffer_.end()); G2::Header hd; try { hd.Decode(&rawPacket_[0], rawPacket_.size()); } catch( std::exception& e) { ReadPacket(); return; } if(hd.dataSize > 0) { g2buffer_.resize(hd.dataSize); ba::async_read(*pSocket_, ba::buffer(g2buffer_), ba::transfer_all(), boost::bind(&G2Node::OnPayload, shared_from_this(), ba::placeholders::error)); } else HandlePacket(); } else if(err != ba::error::operation_aborted) { System::LogDev() << "G2Node::OnPacketHeader " << myInfo_.endpoint.ToString() << " " << err.message() << std::endl; DetachMe(); } }
void G2Node::HandlePacket() { try { G2::Packet pk; pk.GetBuffer()->assign(&rawPacket_[0], rawPacket_.size()); //std::vector<byte> test; //pk.Pack(test); G2::Reader r(pk); if(r.Type() == G2::LNI) { while(r.Next()) { switch(r.Type()) { case G2::GU: r.Read(myInfo_.guid.Bytes(), 16); break; } } } System::GetNetwork()->OnPacket(pk, myInfo_.endpoint, Ip::Protocol::TCP); timestamp_ = System::Now(); } catch(std::exception& e) { System::LogAdv() << "Host " << myInfo_.endpoint.ToString() << " sent a corrupted packet: " << e.what() << std::endl; } ReadPacket(); }
BOOLEAN FilterPacket_ReceiveHandler ( PVOID pHeadBuffer, ULONG ulHeadSize, PNDIS_PACKET pPacket ) /*++ Routine Description: Filters network packets for NDISReceiveHandler. Arguments: ... Return Value: TRUE: This packet should be blocked. FALSE: This packet should pass through. Author: xiaonie 2012/07/12 --*/ { ULONG ulPacketSize; PUCHAR pBuffer = NULL; NDIS_STATUS status; PNDIS_BUFFER pFirstBuffer, pNextBuffer; BOOLEAN bRet = FALSE; NdisQueryPacket(pPacket, NULL, NULL, NULL, &ulPacketSize); if (ulPacketSize == 0) return FALSE; DbgPrint("ulHeadSize == %d, ulPacketSize == %d in FilterPacket_ReceiveHandler!\r\n", ulHeadSize, ulPacketSize); status = NdisAllocateMemoryWithTag(&pBuffer, ulPacketSize + ulHeadSize, '!nmN'); if (status != NDIS_STATUS_SUCCESS/* || pBuffer == NULL */) return FALSE; //obtain content from the packet NdisMoveMemory(pBuffer, pHeadBuffer, ulHeadSize); ReadPacket(pPacket, pBuffer + ulHeadSize, ulPacketSize); bRet = RabbitHole(pBuffer, ulPacketSize + ulHeadSize); NdisFreeMemory(pBuffer, ulPacketSize + ulHeadSize, 0); return bRet; }
/* Read until we get a frame, EOF or error. Return -1 on error, 0 on EOF, 1 if we have a frame. */ int MovieDecoder_FFMpeg::DecodeFrame( float fTargetTime ) { //hack to filter out stuttering if(fTargetTime<m_fLastFrame) { fTargetTime=m_fLastFrame; } else { m_fLastFrame=fTargetTime; } while( 1 ) { int ret = DecodePacket( fTargetTime ); if( ret == 1 ) return 1; if( ret == -1 ) return -1; if( ret == 0 && m_iEOF > 0 ) return 0; /* eof */ ASSERT( ret == 0 ); ret = ReadPacket(); if( ret < 0 ) return ret; /* error */ } }
BOOL ReadMacro(HPTR hpBuf, LPLIST lpMacroList, BOOL fReadFirstPacketOnly) /***********************************************************************/ { LPTSTR lpCommand; MACRO_FILE_HANDLE fh; LPCMDPKT lpCmdPkt; BOOL fError; // zero out the list ListInit(lpMacroList); // Allocate a buffer to read the commands into if (!(lpCommand = (LPTSTR)Alloc(MAX_CMD_LEN))) { Message(IDS_EMEMALLOC); return(FALSE); } while (lpCmdPkt = ReadPacket(&hpBuf, lpCommand, &fError)) { ListAddTail(lpMacroList, lpCmdPkt); if (fReadFirstPacketOnly) break; } FreeUp(lpCommand); if (fError) { DestroyPacketList(lpMacroList); return(FALSE); } return(TRUE); }
BOOL ReadMacro(LPTSTR lpFileName, LPLIST lpMacroList, BOOL fReadFirstPacketOnly) /***********************************************************************/ { LPTSTR lpCommand; MACRO_FILE_HANDLE fh; LPCMDPKT lpCmdPkt; BOOL fError; FNAME OEMName; // zero out the list ListInit(lpMacroList); // Open the macro file #ifdef BUFFERED_IO AnsiToOem(lpFileName, OEMName); fh = fopen(OEMName, _T("rb")); if (fh == NULL) #else fh = FileOpen(lpFileName, FO_READ); if (fh == MACRO_FILE_HANDLE_INVALID) #endif { Message(IDS_EOPEN, lpFileName); return(FALSE); } // Allocate a buffer to read the commands into if (!(lpCommand = (LPTSTR)Alloc(MAX_CMD_LEN))) { #ifdef BUFFERED_IO fclose(fh); #else FileClose(fh); #endif Message(IDS_EMEMALLOC); return(FALSE); } AstralCursor(IDC_WAIT); while (lpCmdPkt = ReadPacket(fh, lpCommand, &fError)) { ListAddTail(lpMacroList, lpCmdPkt); if (fReadFirstPacketOnly) break; } AstralCursor(NULL); FreeUp(lpCommand); #ifdef BUFFERED_IO fclose(fh); #else FileClose(fh); #endif if (fError) { DestroyPacketList(lpMacroList); return(FALSE); } return(TRUE); }
int nrtsRead(NRTS_DL *dl, NRTS_STREAM *stream, INT32 index, UINT8 *buf, UINT32 buflen, NRTS_PKT *pkt, NRTS_CHN *pchn) { NRTS_CHN tmpchn; if (pchn == NULL) pchn = &tmpchn; if(index == pkt->indx) return pkt->orig.len; return ReadPacket(dl, stream, index, buf, buflen, pkt, pchn); }
bool EmbitLoRaModem::Start() { PRINTLN("Sending the netowrk start command"); SendPacket(CMD_START, sizeof(CMD_START)); ReadPacket(); //toddo: check result of readPacket and return actual success or not. return true; }
bool EmbitLoRaModem::SetLoRaWan(bool adr) { PRINTLN("Setting the network preferences to LoRaWAN private network"); if(adr == true) SendPacket(CMD_LORA_PRVNET, sizeof(CMD_LORA_PRVNET)); else SendPacket(CMD_LORA_PRVNET, sizeof(CMD_LORA_PRVNET_NO_ADR)); return ReadPacket(); }
/***************************************************************************** * main *****************************************************************************/ int main(int i_argc, char* pa_argv[]) { int i_fd; int ret = 1; uint8_t data[188]; dvbpsi_t *p_dvbpsi; bool b_ok; if(i_argc != 2) return 1; i_fd = open(pa_argv[1], 0); if (i_fd < 0) return 1; p_dvbpsi = dvbpsi_new(&message, DVBPSI_MSG_DEBUG); if (p_dvbpsi == NULL) goto out; if (!dvbpsi_chain_demux_new(p_dvbpsi, NewSubtable, DelSubtable, NULL)) goto out; b_ok = ReadPacket(i_fd, data); while(b_ok) { uint16_t i_pid = ((uint16_t)(data[1] & 0x1f) << 8) + data[2]; if(i_pid == 0x11) dvbpsi_packet_push(p_dvbpsi, data); b_ok = ReadPacket(i_fd, data); } ret = 0; out: if (p_dvbpsi) { if (!dvbpsi_chain_demux_delete(p_dvbpsi)) ret = 1; dvbpsi_delete(p_dvbpsi); } close(i_fd); return ret; }
/** * @brief volá se jenom v připadě slave * a zasynchronizuje se na správnej čas podle svoji adresy * a přijatéch paketu ktery sou jenom pro něho */ void RecThread::Synchro() { packet_t packet; #ifdef DEBUG_RFM synchrocount++; #endif mutex->Lock(); while (TRUE) { rf_receiver(); rf_writecmd(0); rf_fifo_reset(); rf_writecmd(0); low_level_wait_ffit_high(TIME_INFINITE ); chEvtAddFlags(FFIT_EVENT_FLAG); /* * čeká se až přinde paket pro mě a od mastera a navic bude v pořádku * až se to uloží se čas v kterym přišla zpráva * pak bude poslouchat dycky v tomhle čase za 400ms */ offset = chibios_rt::System::GetTime(); if (ReadPacket(packet) && packet.data.b.DestAddr == MASTER) { rf_sleep(); rf_fifo_reset(); rf_writecmd(0); //tady je bod kdy už sme synchronizovani //v offsetu je čas začátku prvniho přijmu, ktere byl uspesne offset -= 8; offset %= TIME; mutex->Unlock(); /* * rovnou zpracuje paket * pokud idle tak na něho odpoví * pokud nějaké jiné tak ho rovnou zpracuje * vyšší vrstva */ if (packet.IsIdle()) { packet.AnswerIdle(); packet.Send(); } else { //na adrese nezáleži protože ta má vyznam jenom pro mástra LinkLayer::Callback(packet, true, 0); } break; } } }
bool NetServer::listen() { if (!m_pServer) return false; bool bHasPacket = false; ENetEvent event; char hostName[256]; while (enet_host_service (m_pServer, & event, 0) > 0) { switch (event.type) { case ENET_EVENT_TYPE_CONNECT: enet_address_get_host_ip (&event.peer -> address,hostName,256); GfLogTrace ("A new client connected from %s\n",hostName); /* Store any relevant client information here. */ event.peer -> data = (void*)"Client information"; break; case ENET_EVENT_TYPE_RECEIVE: ReadPacket(event); bHasPacket = true; break; case ENET_EVENT_TYPE_DISCONNECT: GfLogTrace("\nA client lost the connection.\n"); enet_address_get_host_ip (&event.peer -> address,hostName,256); GfLogTrace ("A new client disconnected from %s\n",hostName); RemoveDriver(event); SetRaceInfoChanged(true); GfLogTrace ("%s disconected.\n", (char*)event.peer -> data); /* Reset the peer's client information. */ event.peer -> data = NULL; break; case ENET_EVENT_TYPE_NONE: // Do nothing. break; } } if (bHasPacket) m_activeNetworkTime = GfTimeClock(); return bHasPacket; }
/***************************************************************************** * main *****************************************************************************/ int main(int argc, char *argv[]) { AStdData *fp = Stdin; AStdFile _fp; uint8_t data[188]; dvbpsi_t *p_dvbpsi; bool b_ok; (void)DumpDescriptors; if (argc > 1) { if (_fp.open(argv[1], "rb")) fp = &_fp; else { fprintf(stderr, "Failed to open file '%s' for reading\n", argv[1]); exit(1); } } p_dvbpsi = dvbpsi_new(&message, DVBPSI_MSG_WARN); if (p_dvbpsi) { if (dvbpsi_AttachDemux(p_dvbpsi, newsubtable, NULL)) { b_ok = ReadPacket(*fp, data, sizeof(data)); while (b_ok) { uint16_t pid = ((uint16_t)(data[1] & 0x1f) << 8) + data[2]; if (pid == 0x12) dvbpsi_packet_push(p_dvbpsi, data); b_ok = ReadPacket(*fp, data, sizeof(data)); } dvbpsi_DetachDemux(p_dvbpsi); } else fprintf(stderr, "Failed to attach demux to dvbpsi handler\n"); dvbpsi_delete(p_dvbpsi); } else fprintf(stderr, "Failed to create new dvbpsi handler\n"); _fp.close(); return 0; }
BOOLEAN FilterPacket_ProtocolReceiveHandler ( PNDIS_PACKET pPacket ) /*++ Routine Description: Filters network packets for NDISProtocolReceiveHandler. Arguments: pPacket - Pointer to the packet buffer descriptor. Return Value: TRUE: This packet should be blocked. FALSE: This packet should pass through. Author: xiaonie 2012/07/12 --*/ { ULONG ulTotalPacketLength; PUCHAR pBuffer = NULL; BOOLEAN bRet = FALSE; NDIS_STATUS status; NdisQueryPacket(pPacket, NULL, NULL, NULL, &ulTotalPacketLength); if (ulTotalPacketLength == 0) return FALSE; status = NdisAllocateMemoryWithTag(&pBuffer, ulTotalPacketLength, '!nmN'); if (status != NDIS_STATUS_SUCCESS/* || pBuffer == NULL*/) return FALSE; ReadPacket(pPacket, pBuffer, ulTotalPacketLength); // filter it! bRet = RabbitHole(pBuffer, ulTotalPacketLength); NdisFreeMemory(pBuffer, ulTotalPacketLength, 0); return bRet; }
bool NetClient::listenHost(ENetHost * pHost) { if (pHost == NULL) return false; bool bHasPacket = false; ENetEvent event; while (enet_host_service(pHost, & event, 0) > 0) { switch (event.type) { case ENET_EVENT_TYPE_CONNECT: char hostName[256]; enet_address_get_host_ip (&event.peer->address,hostName,256); GfLogTrace ("A new client connected from %s\n",hostName); /* Store any relevant client information here. */ event.peer -> data = (void*)"Client information"; break; case ENET_EVENT_TYPE_RECEIVE: //printf ("A packet of length %u containing %s was received from %s on channel %u.\n", // event.packet -> dataLength, // event.packet -> data, // event.peer -> data, // event.channelID); ReadPacket(event); bHasPacket = true; break; case ENET_EVENT_TYPE_DISCONNECT: if(event.peer == m_pServer) { m_bConnected = false; /* Reset the peer's client information. */ GfLogTrace("Server disconnected\n"); } event.peer -> data = NULL; break; case ENET_EVENT_TYPE_NONE: // Do nothing. break; } } return bHasPacket; }
/***************************************************************************** * main *****************************************************************************/ int main(int i_argc, char* pa_argv[]) { int i_fd; uint8_t data[188]; dvbpsi_t *p_dvbpsi; bool b_ok; if (i_argc != 2) return 1; i_fd = open(pa_argv[1], 0); if (i_fd < 0) return 1; p_dvbpsi = dvbpsi_new(&message, DVBPSI_MSG_DEBUG); if (p_dvbpsi == NULL) goto out; if (!dvbpsi_pat_attach(p_dvbpsi, DumpPAT, NULL)) goto out; b_ok = ReadPacket(i_fd, data); while(b_ok) { uint16_t i_pid = ((uint16_t)(data[1] & 0x1f) << 8) + data[2]; if(i_pid == 0x0) dvbpsi_packet_push(p_dvbpsi, data); b_ok = ReadPacket(i_fd, data); } out: if (p_dvbpsi) { dvbpsi_pat_detach(p_dvbpsi); dvbpsi_delete(p_dvbpsi); } close(i_fd); return 0; }
/***************************************************************************** * main *****************************************************************************/ int main(int i_argc, char* pa_argv[]) { int i_fd; uint8_t data[188]; dvbpsi_t *p_dvbpsi; bool b_ok; if(i_argc != 2) return 1; i_fd = open(pa_argv[1], 0); if (i_fd < 0) return 1; p_dvbpsi = dvbpsi_NewHandle(&message, DVBPSI_MSG_DEBUG); if (p_dvbpsi == NULL) goto out; if (!dvbpsi_AttachDemux(p_dvbpsi, NewSubtable, NULL)) goto out; b_ok = ReadPacket(i_fd, data); while(b_ok) { uint16_t i_pid = ((uint16_t)(data[1] & 0x1f) << 8) + data[2]; if(i_pid == 0x11) dvbpsi_PushPacket(p_dvbpsi, data); b_ok = ReadPacket(i_fd, data); } out: if (p_dvbpsi) { dvbpsi_DetachDemux(p_dvbpsi); dvbpsi_DeleteHandle(p_dvbpsi); } close(i_fd); return 0; }
/// Runs as a thread and handles each packet. It is responsible /// for reading each packet in its entirety from the input pipe, /// filtering it, and then writing it to the output pipe. The /// single void* parameter matches what is expected by pthread. /// @param args An IpPktFilter /// @return Always NULL static void* FilterThread(void* args) { // TODO: implement function IpPktFilter filter = (IpPktFilter) args; unsigned char buffer[MAX_PACKET_LENGTH]; int pktLength; int charsRead; bool isFinished = true; bool isSuccess; OpenPipes(); while(Mode){ if (feof(InPipe)==0){ if (isFinished ){ isSuccess = fread(&pktLength, sizeof(int), 1, InPipe); if (isSuccess){}; } isFinished = ReadPacket(buffer, &charsRead, &pktLength); bool isBlocked = false; if (Mode == MODE_BLOCK_ALL){ isBlocked = true; } else if (Mode == MODE_ALLOW_ALL){ isBlocked = false; } else if (Mode == MODE_FILTER){ isBlocked = ! FilterPacket(filter, buffer); } else if (Mode == 0){ break; } if (!isBlocked){ fwrite(&pktLength, sizeof(int), 1, OutPipe); fwrite(buffer, sizeof(unsigned char), pktLength, OutPipe); fflush(OutPipe); } pktLength -= charsRead; } } fclose(InPipe); fclose(OutPipe); return NULL; }
void DAQSerial::HandleISR() { cli(); if (DAQ_SERIAL.available() != 3) { DAQ_SERIAL.clear(); } // Add packet to queue daq_packet *packet = ReadPacket(); if (packet) { EnqueuePacket(packet); } sei(); }
void CMsregPacketHeader::ReadDataFromFile(CFile& cfFile, DWORD& dwChecksum) { // Read inherited data. CMsregPacket::ReadDataFromFile(cfFile, dwChecksum); // Read customer ID. m_csCustomerId = ReadString(cfFile, dwChecksum); // Read packet count. DWORD dwPackets = ReadDword(cfFile, dwChecksum); // Read packets. DeleteAllPackets(); for (DWORD i = 0; i < dwPackets; i++) { AddPacket(ReadPacket(cfFile)); } }
/** * This function implements jdwpTransportEnv::ReadPacket */ static jdwpTransportError JNICALL TCPIPSocketTran_ReadPacket(jdwpTransportEnv* env, jdwpPacket* packet) { if (packet == 0) { SetLastTranError(env, "packet is 0", 0); return JDWPTRANSPORT_ERROR_ILLEGAL_ARGUMENT; } SOCKET envClientSocket = ((internalEnv*)env->functions->reserved1)->envClientSocket; if (envClientSocket == INVALID_SOCKET) { SetLastTranError(env, "there isn't an open connection to a debugger", 0); LeaveCriticalReadSection(env); return JDWPTRANSPORT_ERROR_ILLEGAL_STATE ; } EnterCriticalReadSection(env); jdwpTransportError err = ReadPacket(env, envClientSocket, packet); LeaveCriticalReadSection(env); return JDWPTRANSPORT_ERROR_NONE; } //TCPIPSocketTran_ReadPacket
static int cpia_usb_transferCmd(void *privdata, u8 *command, u8 *data) { int err = 0; int databytes; struct usb_cpia *ucpia = (struct usb_cpia *)privdata; struct usb_device *udev = ucpia->dev; if (!udev) { DBG("Internal driver error: udev is NULL\n"); return -EINVAL; } if (!command) { DBG("Internal driver error: command is NULL\n"); return -EINVAL; } databytes = (((int)command[7])<<8) | command[6]; if (command[0] == DATA_IN) { u8 buffer[8]; if (!data) { DBG("Internal driver error: data is NULL\n"); return -EINVAL; } err = ReadPacket(udev, command, buffer, 8); if (err < 0) return err; memcpy(data, buffer, databytes); } else if(command[0] == DATA_OUT) WritePacket(udev, command, data, databytes); else { DBG("Unexpected first byte of command: %x\n", command[0]); err = -EINVAL; } return 0; }
/* Read until we get a frame, EOF or error. Return -1 on error, 0 on EOF, 1 if we have a frame. */ int FFMpeg_Helper::GetFrame() { while( 1 ) { int ret = DecodePacket(); if( ret == 1 ) break; if( ret == -1 ) return -1; if( ret == 0 && eof > 0 ) return 0; /* eof */ ASSERT( ret == 0 ); ret = ReadPacket(); if( ret < 0 ) return ret; /* error */ } ++FrameNumber; if( FrameNumber == 1 ) { /* Some videos start with a timestamp other than 0. I think this is used * when audio starts before the video. We don't want to honor that, since * the DShow renderer doesn't and we don't want to break sync compatibility. * * Look at the second frame. (If we have B-frames, the first frame will be an * I-frame with the timestamp of the next P-frame, not its own timestamp, and we * want to ignore that and look at the next B-frame.) */ const float expect = LastFrameDelay; const float actual = CurrentTimestamp; if( actual - expect > 0 ) { LOG->Trace("Expect %f, got %f -> %f", expect, actual, actual - expect ); TimestampOffset = actual - expect; } } return 1; }
void FFMS_AudioSource::DecodeNextBlock(CacheIterator *pos) { CurrentFrame = &Frames[PacketNumber]; AVPacket Packet; if (!ReadPacket(&Packet)) throw FFMS_Exception(FFMS_ERROR_PARSER, FFMS_ERROR_UNKNOWN, "ReadPacket unexpectedly failed to read a packet"); // ReadPacket may have changed the packet number CurrentFrame = &Frames[PacketNumber]; CurrentSample = CurrentFrame->SampleStart; bool GotSamples = false; uint8_t *Data = Packet.data; while (Packet.size > 0) { DecodeFrame.reset(); int GotFrame = 0; int Ret = avcodec_decode_audio4(CodecContext, DecodeFrame, &GotFrame, &Packet); // Should only ever happen if the user chose to ignore decoding errors // during indexing, so continue to just ignore decoding errors if (Ret < 0) break; if (Ret > 0) { Packet.size -= Ret; Packet.data += Ret; if (GotFrame && DecodeFrame->nb_samples > 0) { GotSamples = true; if (pos) CacheBlock(*pos); } } } Packet.data = Data; FreePacket(&Packet); // Zero sample packets aren't included in the index if (GotSamples) ++PacketNumber; }
void CTcpSocket::OnRecv( const system::error_code& ec, size_t nByteTransferred ) { if (ec) { LOGError(ec.message().c_str()); DoClose(); return ; } m_wHaveRecvLength += nByteTransferred; // 黏包解析 USHORT wReadLength = 0; //解析长度修改都是完整消息包 while (true) { const char *pPacketHead = m_szRecvBuffer + wReadLength; USHORT wRemainLength = m_wHaveRecvLength - wReadLength; USHORT wReadPacketLength = ReadPacket(pPacketHead, wRemainLength); if (wReadPacketLength > 0) { wReadLength += wReadPacketLength; } else { if ((wRemainLength > 0) && (wRemainLength != m_wHaveRecvLength)) { memcpy(m_szRecvBuffer, m_szRecvBuffer+wReadLength, wRemainLength); } m_wHaveRecvLength = wRemainLength; break; } } DoRecv(); }
bool EmbitLoRaModem::Send(LoRaPacket* packet, bool ack) { unsigned char length = packet->Write(sendBuffer); PRINTLN("Sending payload: "); for (unsigned char i = 0; i < length; i++) { printHex(sendBuffer[i]); } PRINTLN(); if(ack == true) SendPacket(CMD_SEND_PREFIX, sizeof(CMD_SEND_PREFIX), sendBuffer, length); else SendPacket(CMD_SEND_PREFIX_NO_ACK, sizeof(CMD_SEND_PREFIX_NO_ACK), sendBuffer, length); unsigned char result = ReadPacket(3); if(result != 0){ PRINTLN("Failed to send packet"); return false; } else return true; }
void interrupt NetISR (void) { if (doomcom.command == CMD_SEND) { //I_ColorBlack (0,0,63); WritePacket ((char *)&doomcom.data, doomcom.datalength); } else if (doomcom.command == CMD_GET) { //I_ColorBlack (63,63,0); if (ReadPacket () && packetlen <= sizeof(doomcom.data) ) { doomcom.remotenode = 1; doomcom.datalength = packetlen; memcpy (&doomcom.data, &packet, packetlen); } else doomcom.remotenode = -1; } //I_ColorBlack (0,0,0); }
void CRemoteControl::Update() { if ((!m_bInitialized && !m_isConnecting) || (m_socket == INVALID_SOCKET)) { return; } CIrssMessage mess; if (!ReadPacket(mess)) { return; } switch (mess.GetType()) { case IRSSMT_RegisterClient: m_isConnecting = false; if ((mess.GetFlags() & IRSSMF_Success) != IRSSMF_Success) { //uh oh, it failed to register Close(); CLog::Log(LOGERROR, "IRServerSuite: failed to register XBMC as a client."); } else { m_bInitialized = true; //request info about receivers CIrssMessage mess(IRSSMT_DetectedReceivers, IRSSMF_Request); if (!SendPacket(mess)) { CLog::Log(LOGERROR, "IRServerSuite: failed to send AvailableReceivers packet."); } mess.SetType(IRSSMT_AvailableReceivers); if (!SendPacket(mess)) { CLog::Log(LOGERROR, "IRServerSuite: failed to send AvailableReceivers packet."); } mess.SetType(IRSSMT_ActiveReceivers); if (!SendPacket(mess)) { CLog::Log(LOGERROR, "IRServerSuite: failed to send AvailableReceivers packet."); } } break; case IRSSMT_RemoteEvent: HandleRemoteEvent(mess); break; case IRSSMT_Error: //I suppose the errormessage is in the packet somewhere... CLog::Log(LOGERROR, "IRServerSuite: we got an error message."); break; case IRSSMT_ServerShutdown: Close(); break; case IRSSMT_ServerSuspend: //should we do something? break; case IRSSMT_ServerResume: //should we do something? break; case IRSSMT_AvailableReceivers: { uint32_t size = mess.GetDataSize(); if (size > 0) { char* data = mess.GetData(); char* availablereceivers = new char[size + 1]; memcpy(availablereceivers, data, size); availablereceivers[size] = '\0'; CLog::Log(LOGINFO, "IRServerSuite: Available receivers: %s", availablereceivers); delete[] availablereceivers; } } break; case IRSSMT_DetectedReceivers: { uint32_t size = mess.GetDataSize(); if (size > 0) { char* data = mess.GetData(); char* detectedreceivers = new char[size + 1]; memcpy(detectedreceivers, data, size); detectedreceivers[size] = '\0'; CLog::Log(LOGINFO, "IRServerSuite: Detected receivers: %s", detectedreceivers); delete[] detectedreceivers; } } break; case IRSSMT_ActiveReceivers: { uint32_t size = mess.GetDataSize(); if (size > 0) { char* data = mess.GetData(); char* activereceivers = new char[size + 1]; memcpy(activereceivers, data, size); activereceivers[size] = '\0'; CLog::Log(LOGINFO, "IRServerSuite: Active receivers: %s", activereceivers); delete[] activereceivers; } } break; } }
void handle_event(int fd, short, void *v) { bool success; size_t index = (size_t) v; Assert(index < connections.Size()); ConnectData *cdata = connections[index]; Assert(cdata->live); if (cdata->write_buf.size != 0) { success = WritePacket(fd, &cdata->write_buf); if (success) { cdata->write_buf.base = NULL; cdata->write_buf.pos = NULL; cdata->write_buf.size = 0; } } else { size_t length = cdata->read_buf.pos - cdata->read_buf.base; success = ReadPacket(fd, &cdata->read_buf); if (success) { size_t data_length = cdata->read_buf.pos - cdata->read_buf.base - UINT32_LENGTH; Buffer transaction_buf(cdata->read_buf.base + UINT32_LENGTH, data_length); Transaction *t = new Transaction(); if (!t->Read(&transaction_buf)) { logout << "ERROR: Corrupt packet data" << endl; delete t; return; } handling_transaction = true; t->Execute(); cdata->read_buf.pos = cdata->read_buf.base; cdata->read_buf.Ensure(UINT32_LENGTH); cdata->read_buf.pos += UINT32_LENGTH; t->WriteResult(&cdata->read_buf); cdata->write_buf.base = cdata->read_buf.base; cdata->write_buf.pos = cdata->write_buf.base; cdata->write_buf.size = cdata->read_buf.pos - cdata->read_buf.base; cdata->read_buf.pos = cdata->read_buf.base; success = WritePacket(fd, &cdata->write_buf); if (success) { cdata->write_buf.base = NULL; cdata->write_buf.pos = NULL; cdata->write_buf.size = 0; } // watch for initial and final transactions. if (t->IsInitial()) { Assert(!spawn_count.IsSpecified()); received_initial++; } if (t->IsFinal()) { Assert(received_final < received_initial); received_final++; if (received_final == received_initial) { // this was the last client, so cleanup and exit. logout << "Final transaction received, finishing..." << endl << flush; close(server_socket); ClearBlockCaches(); ClearMemoryCaches(); AnalysisFinish(0); } } delete t; handling_transaction = false; } else if ((ssize_t) length == cdata->read_buf.pos - cdata->read_buf.base) { // connection is closed. there is nothing to read so remove the event. event_del(&cdata->ev); close(cdata->fd); cdata->live = false; cdata->read_buf.Reset(0); cdata->write_buf.Reset(0); } } }