/*****************************************************************************
* 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);
}
}
}
