diff --git a/src/ccodecstream.cpp b/src/ccodecstream.cpp index aaf26b6..83259b7 100644 --- a/src/ccodecstream.cpp +++ b/src/ccodecstream.cpp @@ -67,19 +67,6 @@ CCodecStream::~CCodecStream() { m_Future.get(); } - - // empty local queue - while ( !m_LocalQueue.empty() ) - { - delete m_LocalQueue.front(); - m_LocalQueue.pop(); - } - // empty ourselves - while ( !empty() ) - { - delete front(); - pop(); - } } //////////////////////////////////////////////////////////////////////////////////////// @@ -200,15 +187,16 @@ void CCodecStream::Task(void) // pop the original packet if ( !m_LocalQueue.empty() ) { - CDvFramePacket *Packet = (CDvFramePacket *)m_LocalQueue.front(); + auto Packet = m_LocalQueue.front(); + auto Frame = (CDvFramePacket *)Packet.get(); m_LocalQueue.pop(); // todo: check the PID // update content with transcoded ambe - Packet->SetAmbe(m_uiCodecOut, Ambe); + Frame->SetAmbe(m_uiCodecOut, Ambe); // tag syncs in DvData - if ( (m_uiCodecOut == CODEC_AMBEPLUS) && (Packet->GetPacketId() % 21) == 0 ) + if ( (m_uiCodecOut == CODEC_AMBEPLUS) && (Frame->GetPacketId() % 21) == 0 ) { - Packet->SetDvData(DStarSync); + Frame->SetDvData(DStarSync); } // and push it back to client m_PacketStream->Lock(); @@ -226,7 +214,8 @@ void CCodecStream::Task(void) while ( !empty() ) { // yes, pop it from queue - CPacket *Packet = front(); + auto Packet = front(); + auto Frame = (CDvFramePacket *)Packet.get(); pop(); // yes, send to ambed @@ -235,7 +224,7 @@ void CCodecStream::Task(void) // and that the packet needs transcoding m_StatsTimer.Now(); m_uiTotalPackets++; - EncodeAmbePacket(&Buffer, ((CDvFramePacket *)Packet)->GetAmbe(m_uiCodecIn)); + EncodeAmbePacket(&Buffer, Frame->GetAmbe(m_uiCodecIn)); m_Socket.Send(Buffer, m_Ip, m_uiPort); // and push to our local queue diff --git a/src/cdcsprotocol.cpp b/src/cdcsprotocol.cpp index 4bb5b09..f9ee5ee 100644 --- a/src/cdcsprotocol.cpp +++ b/src/cdcsprotocol.cpp @@ -53,12 +53,12 @@ bool CDcsProtocol::Init(void) void CDcsProtocol::Task(void) { - CBuffer Buffer; - CIp Ip; - CCallsign Callsign; - char ToLinkModule; - CDvHeaderPacket *Header; - CDvFramePacket *Frame; + CBuffer Buffer; + CIp Ip; + CCallsign Callsign; + char ToLinkModule; + std::unique_ptr Header; + std::unique_ptr Frame; // handle incoming packets #if DSTAR_IPV6==true @@ -72,7 +72,7 @@ void CDcsProtocol::Task(void) #endif { // crack the packet - if ( IsValidDvPacket(Buffer, &Header, &Frame) ) + if ( IsValidDvPacket(Buffer, Header, Frame) ) { //std::cout << "DCS DV packet" << std::endl; @@ -90,14 +90,9 @@ void CDcsProtocol::Task(void) else { //std::cout << "DCS DV last frame" << std::endl; - OnDvLastFramePacketIn((CDvLastFramePacket *)Frame, &Ip); + OnDvLastFramePacketIn((std::unique_ptr &)Frame, &Ip); } } - else - { - delete Header; - delete Frame; - } } else if ( IsValidConnectPacket(Buffer, &Callsign, &ToLinkModule) ) { @@ -197,10 +192,8 @@ void CDcsProtocol::Task(void) //////////////////////////////////////////////////////////////////////////////////////// // streams helpers -bool CDcsProtocol::OnDvHeaderPacketIn(CDvHeaderPacket *Header, const CIp &Ip) +void CDcsProtocol::OnDvHeaderPacketIn(std::unique_ptr &Header, const CIp &Ip) { - bool newstream = false; - // find the stream CPacketStream *stream = GetStream(Header->GetStreamId()); if ( stream == nullptr ) @@ -219,7 +212,6 @@ bool CDcsProtocol::OnDvHeaderPacketIn(CDvHeaderPacket *Header, const CIp &Ip) { // keep the handle m_Streams.push_back(stream); - newstream = true; } } // release @@ -228,24 +220,13 @@ bool CDcsProtocol::OnDvHeaderPacketIn(CDvHeaderPacket *Header, const CIp &Ip) // update last heard g_Reflector.GetUsers()->Hearing(Header->GetMyCallsign(), via, Header->GetRpt2Callsign()); g_Reflector.ReleaseUsers(); - - // delete header if needed - if ( !newstream ) - { - delete Header; - } } else { // stream already open // skip packet, but tickle the stream stream->Tickle(); - // and delete packet - delete Header; } - - // done - return newstream; } //////////////////////////////////////////////////////////////////////////////////////// @@ -257,7 +238,7 @@ void CDcsProtocol::HandleQueue(void) while ( !m_Queue.empty() ) { // get the packet - CPacket *packet = m_Queue.front(); + auto packet = m_Queue.front(); m_Queue.pop(); // get our sender's id @@ -311,9 +292,6 @@ void CDcsProtocol::HandleQueue(void) g_Reflector.ReleaseClients(); } } - - // done - delete packet; } m_Queue.Unlock(); } @@ -411,58 +389,41 @@ bool CDcsProtocol::IsValidKeepAlivePacket(const CBuffer &Buffer, CCallsign *call return valid; } -bool CDcsProtocol::IsValidDvPacket(const CBuffer &Buffer, CDvHeaderPacket **header, CDvFramePacket **frame) +bool CDcsProtocol::IsValidDvPacket(const CBuffer &Buffer, std::unique_ptr &header, std::unique_ptr &frame) { uint8 tag[] = { '0','0','0','1' }; - bool valid = false; - *header = nullptr; - *frame = nullptr; - if ( (Buffer.size() >= 100) && (Buffer.Compare(tag, sizeof(tag)) == 0) ) { // get the header - *header = new CDvHeaderPacket((struct dstar_header *)&(Buffer.data()[4]), *((uint16 *)&(Buffer.data()[43])), 0x80); + header = std::unique_ptr(new CDvHeaderPacket((struct dstar_header *)&(Buffer.data()[4]), *((uint16 *)&(Buffer.data()[43])), 0x80)); // get the frame - if ( ((Buffer.data()[45]) & 0x40) != 0 ) + if ( Buffer.data()[45] & 0x40U ) { // it's the last frame - *frame = new CDvLastFramePacket((struct dstar_dvframe *)&(Buffer.data()[46]), *((uint16 *)&(Buffer.data()[43])), Buffer.data()[45]); + frame = std::unique_ptr(new CDvLastFramePacket((struct dstar_dvframe *)&(Buffer.data()[46]), *((uint16 *)&(Buffer.data()[43])), Buffer.data()[45])); } else { // it's a regular DV frame - *frame = new CDvFramePacket((struct dstar_dvframe *)&(Buffer.data()[46]), *((uint16 *)&(Buffer.data()[43])), Buffer.data()[45]); + frame = std::unique_ptr(new CDvFramePacket((struct dstar_dvframe *)&(Buffer.data()[46]), *((uint16 *)&(Buffer.data()[43])), Buffer.data()[45])); } // check validity of packets - if ( !((*header)->IsValid() && (*frame)->IsValid()) ) - { - delete *header; - delete *frame; - *header = nullptr; - *frame = nullptr; - } - else - { - valid = true; - } + if ( header && header->IsValid() && frame && frame->IsValid() ) + return true; } - // done - return valid; + return false; } bool CDcsProtocol::IsIgnorePacket(const CBuffer &Buffer) { - bool valid = false; uint8 tag[] = { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, }; - if ( Buffer.size() == 15 ) - { - valid = (Buffer.Compare(tag, sizeof(tag)) == 0); - } - return valid; + if ( 15==Buffer.size() == 15 && 0==Buffer.Compare(tag, sizeof(tag)) ) + return true; + return false; } diff --git a/src/cdcsprotocol.h b/src/cdcsprotocol.h index 0bddece..f960ead 100644 --- a/src/cdcsprotocol.h +++ b/src/cdcsprotocol.h @@ -64,13 +64,13 @@ protected: void HandleKeepalives(void); // stream helpers - bool OnDvHeaderPacketIn(CDvHeaderPacket *, const CIp &); + void OnDvHeaderPacketIn(std::unique_ptr &, const CIp &); // packet decoding helpers bool IsValidConnectPacket(const CBuffer &, CCallsign *, char *); bool IsValidDisconnectPacket(const CBuffer &, CCallsign *); bool IsValidKeepAlivePacket(const CBuffer &, CCallsign *); - bool IsValidDvPacket(const CBuffer &, CDvHeaderPacket **, CDvFramePacket **); + bool IsValidDvPacket(const CBuffer &, std::unique_ptr &, std::unique_ptr &); bool IsIgnorePacket(const CBuffer &); // packet encoding helpers diff --git a/src/cdextraprotocol.cpp b/src/cdextraprotocol.cpp index 36ebdc2..33b876c 100644 --- a/src/cdextraprotocol.cpp +++ b/src/cdextraprotocol.cpp @@ -59,9 +59,9 @@ void CDextraProtocol::Task(void) CCallsign Callsign; char ToLinkModule; int ProtRev; - CDvHeaderPacket *Header; - CDvFramePacket *Frame; - CDvLastFramePacket *LastFrame; + std::unique_ptr Header; + std::unique_ptr Frame; + std::unique_ptr LastFrame; // any incoming packet ? #if DSTAR_IPV6==true @@ -75,34 +75,20 @@ void CDextraProtocol::Task(void) #endif { // crack the packet - if ( (Frame = IsValidDvFramePacket(Buffer)) != nullptr ) + if ( IsValidDvFramePacket(Buffer, Frame) ) { - //std::cout << "DExtra DV frame" << std::endl; - - // handle it OnDvFramePacketIn(Frame, &Ip); } - else if ( (Header = IsValidDvHeaderPacket(Buffer)) != nullptr ) + else if ( IsValidDvHeaderPacket(Buffer, Header) ) { - //std::cout << "DExtra DV header:" << std::endl << *Header << std::endl; - //std::cout << "DExtra DV header:" << std::endl; - // callsign muted? if ( g_GateKeeper.MayTransmit(Header->GetMyCallsign(), Ip, PROTOCOL_DEXTRA, Header->GetRpt2Module()) ) { - // handle it OnDvHeaderPacketIn(Header, Ip); } - else - { - delete Header; - } } - else if ( (LastFrame = IsValidDvLastFramePacket(Buffer)) != nullptr ) + else if ( IsValidDvLastFramePacket(Buffer, LastFrame) ) { - //std::cout << "DExtra DV last frame" << std::endl; - - // handle it OnDvLastFramePacketIn(LastFrame, &Ip); } else if ( IsValidConnectPacket(Buffer, &Callsign, &ToLinkModule, &ProtRev) ) @@ -243,7 +229,7 @@ void CDextraProtocol::HandleQueue(void) while ( !m_Queue.empty() ) { // get the packet - CPacket *packet = m_Queue.front(); + auto packet = m_Queue.front(); m_Queue.pop(); // encode it @@ -269,10 +255,6 @@ void CDextraProtocol::HandleQueue(void) } g_Reflector.ReleaseClients(); } - - - // done - delete packet; } m_Queue.Unlock(); } @@ -413,10 +395,8 @@ void CDextraProtocol::HandlePeerLinks(void) //////////////////////////////////////////////////////////////////////////////////////// // streams helpers -bool CDextraProtocol::OnDvHeaderPacketIn(CDvHeaderPacket *Header, const CIp &Ip) +void CDextraProtocol::OnDvHeaderPacketIn(std::unique_ptr &Header, const CIp &Ip) { - bool newstream = false; - // find the stream CPacketStream *stream = GetStream(Header->GetStreamId()); if ( stream == nullptr ) @@ -442,7 +422,6 @@ bool CDextraProtocol::OnDvHeaderPacketIn(CDvHeaderPacket *Header, const CIp &Ip) { // keep the handle m_Streams.push_back(stream); - newstream = true; } } // release @@ -451,24 +430,13 @@ bool CDextraProtocol::OnDvHeaderPacketIn(CDvHeaderPacket *Header, const CIp &Ip) // update last heard g_Reflector.GetUsers()->Hearing(Header->GetMyCallsign(), via, Header->GetRpt2Callsign()); g_Reflector.ReleaseUsers(); - - // delete header if needed - if ( !newstream ) - { - delete Header; - } } else { // stream already open // skip packet, but tickle the stream stream->Tickle(); - // and delete packet - delete Header; } - - // done - return newstream; } //////////////////////////////////////////////////////////////////////////////////////// @@ -524,66 +492,43 @@ bool CDextraProtocol::IsValidKeepAlivePacket(const CBuffer &Buffer, CCallsign *c return valid; } -CDvHeaderPacket *CDextraProtocol::IsValidDvHeaderPacket(const CBuffer &Buffer) +bool CDextraProtocol::IsValidDvHeaderPacket(const CBuffer &Buffer, std::unique_ptr &header) { - CDvHeaderPacket *header = nullptr; - - if ( (Buffer.size() == 56) && (Buffer.Compare((uint8 *)"DSVT", 4) == 0) && - (Buffer.data()[4] == 0x10) && (Buffer.data()[8] == 0x20) ) + if ( 56==Buffer.size() && 0==Buffer.Compare((uint8 *)"DSVT", 4) && 0x10U==Buffer.data()[4] && 0x20U==Buffer.data()[8] ) { // create packet - header = new CDvHeaderPacket((struct dstar_header *)&(Buffer.data()[15]), - *((uint16 *)&(Buffer.data()[12])), 0x80); + header = std::unique_ptr(new CDvHeaderPacket((struct dstar_header *)&(Buffer.data()[15]), *((uint16 *)&(Buffer.data()[12])), 0x80)); // check validity of packet - if ( !header->IsValid() ) - { - delete header; - header = nullptr; - } + if ( header && header->IsValid() ) + return true; } - return header; + return false; } -CDvFramePacket *CDextraProtocol::IsValidDvFramePacket(const CBuffer &Buffer) +bool CDextraProtocol::IsValidDvFramePacket(const CBuffer &Buffer, std::unique_ptr &dvframe) { - CDvFramePacket *dvframe = nullptr; - - if ( (Buffer.size() == 27) && (Buffer.Compare((uint8 *)"DSVT", 4) == 0) && - (Buffer.data()[4] == 0x20) && (Buffer.data()[8] == 0x20) && - ((Buffer.data()[14] & 0x40) == 0) ) + if ( 27==Buffer.size() && 0==Buffer.Compare((uint8 *)"DSVT", 4) && 0x20U==Buffer.data()[4] && 0x20U==Buffer.data()[8] && 0U==(Buffer.data()[14] & 0x40U) ) { // create packet - dvframe = new CDvFramePacket((struct dstar_dvframe *)&(Buffer.data()[15]), - *((uint16 *)&(Buffer.data()[12])), Buffer.data()[14]); + dvframe = std::unique_ptr(new CDvFramePacket((struct dstar_dvframe *)&(Buffer.data()[15]), *((uint16 *)&(Buffer.data()[12])), Buffer.data()[14])); // check validity of packet - if ( !dvframe->IsValid() ) - { - delete dvframe; - dvframe = nullptr; - } + if ( dvframe && dvframe->IsValid() ) + return true; } - return dvframe; + return false; } -CDvLastFramePacket *CDextraProtocol::IsValidDvLastFramePacket(const CBuffer &Buffer) +bool CDextraProtocol::IsValidDvLastFramePacket(const CBuffer &Buffer, std::unique_ptr &dvframe) { - CDvLastFramePacket *dvframe = nullptr; - - if ( (Buffer.size() == 27) && (Buffer.Compare((uint8 *)"DSVT", 4) == 0) && - (Buffer.data()[4] == 0x20) && (Buffer.data()[8] == 0x20) && - ((Buffer.data()[14] & 0x40) != 0) ) + if ( 27==Buffer.size() && 0==Buffer.Compare((uint8 *)"DSVT", 4) && 0x20U==Buffer.data()[4] && 0x20U==Buffer.data()[8] && (Buffer.data()[14] & 0x40) ) { // create packet - dvframe = new CDvLastFramePacket((struct dstar_dvframe *)&(Buffer.data()[15]), - *((uint16 *)&(Buffer.data()[12])), Buffer.data()[14]); + dvframe = std::unique_ptr(new CDvLastFramePacket((struct dstar_dvframe *)&(Buffer.data()[15]), *((uint16 *)&(Buffer.data()[12])), Buffer.data()[14])); // check validity of packet - if ( !dvframe->IsValid() ) - { - delete dvframe; - dvframe = nullptr; - } + if ( dvframe && dvframe->IsValid() ) + return true; } - return dvframe; + return false; } //////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/cdextraprotocol.h b/src/cdextraprotocol.h index 4393f88..3a83e0e 100644 --- a/src/cdextraprotocol.h +++ b/src/cdextraprotocol.h @@ -73,31 +73,31 @@ protected: void HandleKeepalives(void); // stream helpers - bool OnDvHeaderPacketIn(CDvHeaderPacket *, const CIp &); + void OnDvHeaderPacketIn(std::unique_ptr &, const CIp &); // packet decoding helpers - bool IsValidConnectPacket(const CBuffer &, CCallsign *, char *, int *); - bool IsValidDisconnectPacket(const CBuffer &, CCallsign *); - bool IsValidKeepAlivePacket(const CBuffer &, CCallsign *); - CDvHeaderPacket *IsValidDvHeaderPacket(const CBuffer &); - CDvFramePacket *IsValidDvFramePacket(const CBuffer &); - CDvLastFramePacket *IsValidDvLastFramePacket(const CBuffer &); + bool IsValidConnectPacket( const CBuffer &, CCallsign *, char *, int *); + bool IsValidDisconnectPacket( const CBuffer &, CCallsign *); + bool IsValidKeepAlivePacket( const CBuffer &, CCallsign *); + bool IsValidDvHeaderPacket( const CBuffer &, std::unique_ptr &); + bool IsValidDvFramePacket( const CBuffer &, std::unique_ptr &); + bool IsValidDvLastFramePacket(const CBuffer &, std::unique_ptr &); // packet encoding helpers - void EncodeKeepAlivePacket(CBuffer *); - void EncodeConnectPacket(CBuffer *, const char *); - void EncodeConnectAckPacket(CBuffer *, int); - void EncodeConnectNackPacket(CBuffer *); - void EncodeDisconnectPacket(CBuffer *, char); - void EncodeDisconnectedPacket(CBuffer *); - bool EncodeDvHeaderPacket(const CDvHeaderPacket &, CBuffer *) const; - bool EncodeDvFramePacket(const CDvFramePacket &, CBuffer *) const; - bool EncodeDvLastFramePacket(const CDvLastFramePacket &, CBuffer *) const; + void EncodeKeepAlivePacket(CBuffer *); + void EncodeConnectPacket(CBuffer *, const char *); + void EncodeConnectAckPacket(CBuffer *, int); + void EncodeConnectNackPacket(CBuffer *); + void EncodeDisconnectPacket(CBuffer *, char); + void EncodeDisconnectedPacket(CBuffer *); + bool EncodeDvHeaderPacket(const CDvHeaderPacket &, CBuffer *) const; + bool EncodeDvFramePacket(const CDvFramePacket &, CBuffer *) const; + bool EncodeDvLastFramePacket(const CDvLastFramePacket &, CBuffer *) const; protected: // time - CTimePoint m_LastKeepaliveTime; - CTimePoint m_LastPeersLinkTime; + CTimePoint m_LastKeepaliveTime; + CTimePoint m_LastPeersLinkTime; }; //////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/cdmrmmdvmprotocol.cpp b/src/cdmrmmdvmprotocol.cpp index 6bd67d9..0c3ccf7 100644 --- a/src/cdmrmmdvmprotocol.cpp +++ b/src/cdmrmmdvmprotocol.cpp @@ -79,15 +79,15 @@ bool CDmrmmdvmProtocol::Initalize(const char *type, const uint16 port, const boo void CDmrmmdvmProtocol::Task(void) { - CBuffer Buffer; - CIp Ip; - CCallsign Callsign; - int iRssi; - uint8 Cmd; - uint8 CallType; - CDvHeaderPacket *Header; - CDvFramePacket *Frames[3]; - CDvLastFramePacket *LastFrame; + CBuffer Buffer; + CIp Ip; + CCallsign Callsign; + int iRssi; + uint8 Cmd; + uint8 CallType; + std::unique_ptr Header; + std::unique_ptr LastFrame; + std::array, 3> Frames; // handle incoming packets #if DMR_IPV6==true @@ -104,33 +104,22 @@ void CDmrmmdvmProtocol::Task(void) // crack the packet if ( IsValidDvFramePacket(Buffer, Frames) ) { - //std::cout << "DMRmmdvm DV frame" << std::endl; - for ( int i = 0; i < 3; i++ ) { - OnDvFramePacketIn(Frames[i], &Ip); + OnDvFramePacketIn(Frames.at(i), &Ip); } } - else if ( IsValidDvHeaderPacket(Buffer, &Header, &Cmd, &CallType) ) + else if ( IsValidDvHeaderPacket(Buffer, Header, &Cmd, &CallType) ) { - //std::cout << "DMRmmdvm DV header:" << std::endl << *Header << std::endl; - //std::cout << "DMRmmdvm DV header" << std::endl; - // callsign muted? if ( g_GateKeeper.MayTransmit(Header->GetMyCallsign(), Ip, PROTOCOL_DMRMMDVM) ) { // handle it OnDvHeaderPacketIn(Header, Ip, Cmd, CallType); } - else - { - delete Header; - } } - else if ( IsValidDvLastFramePacket(Buffer, &LastFrame) ) + else if ( IsValidDvLastFramePacket(Buffer, LastFrame) ) { - //std::cout << "DMRmmdvm DV last frame" << std::endl; - OnDvLastFramePacketIn(LastFrame, &Ip); } else if ( IsValidConnectPacket(Buffer, &Callsign, Ip) ) @@ -272,7 +261,7 @@ void CDmrmmdvmProtocol::Task(void) //////////////////////////////////////////////////////////////////////////////////////// // streams helpers -bool CDmrmmdvmProtocol::OnDvHeaderPacketIn(CDvHeaderPacket *Header, const CIp &Ip, uint8 cmd, uint8 CallType) +bool CDmrmmdvmProtocol::OnDvHeaderPacketIn(std::unique_ptr &Header, const CIp &Ip, uint8 cmd, uint8 CallType) { bool newstream = false; bool lastheard = false; @@ -350,20 +339,12 @@ bool CDmrmmdvmProtocol::OnDvHeaderPacketIn(CDvHeaderPacket *Header, const CIp &I g_Reflector.GetUsers()->Hearing(Header->GetMyCallsign(), via, Header->GetRpt2Callsign()); g_Reflector.ReleaseUsers(); } - - // delete header if needed - if ( !newstream ) - { - delete Header; - } } else { // stream already open // skip packet, but tickle the stream stream->Tickle(); - // and delete packet - delete Header; } // done @@ -380,7 +361,7 @@ void CDmrmmdvmProtocol::HandleQueue(void) while ( !m_Queue.empty() ) { // get the packet - CPacket *packet = m_Queue.front(); + auto packet = m_Queue.front(); m_Queue.pop(); // get our sender's id @@ -398,7 +379,7 @@ void CDmrmmdvmProtocol::HandleQueue(void) m_StreamsCache[iModId].m_uiSeqId = 0; // encode it - EncodeDvHeaderPacket((const CDvHeaderPacket &)*packet, m_StreamsCache[iModId].m_uiSeqId, &buffer); + EncodeDvHeaderPacket((CDvHeaderPacket &)*packet, m_StreamsCache[iModId].m_uiSeqId, &buffer); m_StreamsCache[iModId].m_uiSeqId = 1; } // check if it's a last frame @@ -454,9 +435,6 @@ void CDmrmmdvmProtocol::HandleQueue(void) } g_Reflector.ReleaseClients(); } - - // done - delete packet; } m_Queue.Unlock(); } @@ -620,12 +598,10 @@ bool CDmrmmdvmProtocol::IsValidRssiPacket(const CBuffer &Buffer, CCallsign *call return valid; } -bool CDmrmmdvmProtocol::IsValidDvHeaderPacket(const CBuffer &Buffer, CDvHeaderPacket **header, uint8 *cmd, uint8 *CallType) +bool CDmrmmdvmProtocol::IsValidDvHeaderPacket(const CBuffer &Buffer, std::unique_ptr &header, uint8 *cmd, uint8 *CallType) { uint8 tag[] = { 'D','M','R','D' }; - bool valid = false; - *header = nullptr; *cmd = CMD_NONE; if ( (Buffer.size() == 55) && (Buffer.Compare(tag, sizeof(tag)) == 0) ) @@ -687,29 +663,19 @@ bool CDmrmmdvmProtocol::IsValidDvHeaderPacket(const CBuffer &Buffer, CDvHeaderPa rpt2.SetModule(DmrDstIdToModule(uiDstId)); // and packet - *header = new CDvHeaderPacket(uiSrcId, CCallsign("CQCQCQ"), rpt1, rpt2, uiStreamId, 0, 0); - valid = (*header)->IsValid(); - if ( !valid ) - { - delete *header; - *header = nullptr; - } + header = std::unique_ptr(new CDvHeaderPacket(uiSrcId, CCallsign("CQCQCQ"), rpt1, rpt2, uiStreamId, 0, 0)); + if ( header && header->IsValid() ) + return true; } } } - // done - return valid; + return false; } -bool CDmrmmdvmProtocol::IsValidDvFramePacket(const CBuffer &Buffer, CDvFramePacket **frames) +bool CDmrmmdvmProtocol::IsValidDvFramePacket(const CBuffer &Buffer, std::array, 3> &frames) { uint8 tag[] = { 'D','M','R','D' }; - bool valid = false; - frames[0] = nullptr; - frames[1] = nullptr; - frames[2] = nullptr; - if ( (Buffer.size() == 55) && (Buffer.Compare(tag, sizeof(tag)) == 0) ) { // frame details @@ -752,31 +718,28 @@ bool CDmrmmdvmProtocol::IsValidDvFramePacket(const CBuffer &Buffer, CDvFramePack // and create 3 dv frames // frame1 memcpy(dmrambe, &dmr3ambe[0], 9); - frames[0] = new CDvFramePacket(dmrambe, dmrsync, uiStreamId, uiVoiceSeq, 1); + frames[0] = std::unique_ptr(new CDvFramePacket(dmrambe, dmrsync, uiStreamId, uiVoiceSeq, 1)); // frame2 memcpy(dmrambe, &dmr3ambe[9], 9); - frames[1] = new CDvFramePacket(dmrambe, dmrsync, uiStreamId, uiVoiceSeq, 2); + frames[1] = std::unique_ptr(new CDvFramePacket(dmrambe, dmrsync, uiStreamId, uiVoiceSeq, 2)); // frame3 memcpy(dmrambe, &dmr3ambe[18], 9); - frames[2] = new CDvFramePacket(dmrambe, dmrsync, uiStreamId, uiVoiceSeq, 3); + frames[2] = std::unique_ptr(new CDvFramePacket(dmrambe, dmrsync, uiStreamId, uiVoiceSeq, 3)); // check - valid = true; + if (frames[0] && frames[1] && frames[2]) + return true; } } - // done - return valid; + return false; } -bool CDmrmmdvmProtocol::IsValidDvLastFramePacket(const CBuffer &Buffer, CDvLastFramePacket **frame) +bool CDmrmmdvmProtocol::IsValidDvLastFramePacket(const CBuffer &Buffer, std::unique_ptr &frame) { uint8 tag[] = { 'D','M','R','D' }; - bool valid = false; - *frame = nullptr; - if ( (Buffer.size() == 55) && (Buffer.Compare(tag, sizeof(tag)) == 0) ) { // frame details @@ -817,15 +780,13 @@ bool CDmrmmdvmProtocol::IsValidDvLastFramePacket(const CBuffer &Buffer, CDvLastF // and packet - *frame = new CDvLastFramePacket(ambe, dmrsync, uiStreamId, 0, 0); - - // check - valid = true; + frame = std::unique_ptr(new CDvLastFramePacket(ambe, dmrsync, uiStreamId, 0, 0)); + if (frame) + return true; } } } - // done - return valid; + return false; } //////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/cdmrmmdvmprotocol.h b/src/cdmrmmdvmprotocol.h index 8b63a28..dcbf996 100644 --- a/src/cdmrmmdvmprotocol.h +++ b/src/cdmrmmdvmprotocol.h @@ -4,6 +4,7 @@ // // Created by Jean-Luc Deltombe (LX3JL) on 04/03/2017. // Copyright © 2015 Jean-Luc Deltombe (LX3JL). All rights reserved. +// Copyright © 2020 Thomas A. Early, N7TAE // // ---------------------------------------------------------------------------- // This file is part of xlxd. @@ -80,7 +81,7 @@ protected: void HandleKeepalives(void); // stream helpers - bool OnDvHeaderPacketIn(CDvHeaderPacket *, const CIp &, uint8, uint8); + bool OnDvHeaderPacketIn(std::unique_ptr &, const CIp &, uint8, uint8); // packet decoding helpers bool IsValidConnectPacket(const CBuffer &, CCallsign *, const CIp &); @@ -90,9 +91,9 @@ protected: bool IsValidOptionPacket(const CBuffer &, CCallsign *); bool IsValidKeepAlivePacket(const CBuffer &, CCallsign *); bool IsValidRssiPacket(const CBuffer &, CCallsign *, int *); - bool IsValidDvHeaderPacket(const CBuffer &, CDvHeaderPacket **, uint8 *, uint8 *); - bool IsValidDvFramePacket(const CBuffer &, CDvFramePacket **); - bool IsValidDvLastFramePacket(const CBuffer &, CDvLastFramePacket **); + bool IsValidDvHeaderPacket(const CBuffer &, std::unique_ptr &, uint8 *, uint8 *); + bool IsValidDvFramePacket(const CBuffer &, std::array, 3> &); + bool IsValidDvLastFramePacket(const CBuffer &, std::unique_ptr &); // packet encoding helpers void EncodeKeepAlivePacket(CBuffer *, std::shared_ptr); diff --git a/src/cdmrplusprotocol.cpp b/src/cdmrplusprotocol.cpp index 1113c89..90c65e5 100644 --- a/src/cdmrplusprotocol.cpp +++ b/src/cdmrplusprotocol.cpp @@ -71,12 +71,12 @@ bool CDmrplusProtocol::Initalize(const char *type, const uint16 port, const bool void CDmrplusProtocol::Task(void) { - CBuffer Buffer; - CIp Ip; - CCallsign Callsign; - char ToLinkModule; - CDvHeaderPacket *Header; - CDvFramePacket *Frames[3]; + CBuffer Buffer; + CIp Ip; + CCallsign Callsign; + char ToLinkModule; + std::unique_ptr Header; + std::array, 3> Frames; // handle incoming packets #if DMR_IPV6==true @@ -92,40 +92,19 @@ void CDmrplusProtocol::Task(void) // crack the packet if ( IsValidDvFramePacket(Ip, Buffer, Frames) ) { - //std::cout << "DMRplus DV frame" << std::endl; - //Buffer.DebugDump(g_Reflector.m_DebugFile); - for ( int i = 0; i < 3; i++ ) { OnDvFramePacketIn(Frames[i], &Ip); - /*if ( !Frames[i]->IsLastPacket() ) - { - //std::cout << "DMRplus DV frame" << std::endl; - OnDvFramePacketIn(Frames[i], &Ip); - } - else - { - //std::cout << "DMRplus DV last frame" << std::endl; - OnDvLastFramePacketIn((CDvLastFramePacket *)Frames[i], &Ip); - }*/ } } - else if ( IsValidDvHeaderPacket(Ip, Buffer, &Header) ) + else if ( IsValidDvHeaderPacket(Ip, Buffer, Header) ) { - //std::cout << "DMRplus DV header:" << std::endl; - //std::cout << "DMRplus DV header:" << std::endl << *Header << std::endl; - //Buffer.DebugDump(g_Reflector.m_DebugFile); - // callsign muted? if ( g_GateKeeper.MayTransmit(Header->GetMyCallsign(), Ip, PROTOCOL_DMRPLUS) ) { // handle it OnDvHeaderPacketIn(Header, Ip); } - else - { - delete Header; - } } else if ( IsValidConnectPacket(Buffer, &Callsign, &ToLinkModule, Ip) ) { @@ -204,10 +183,8 @@ void CDmrplusProtocol::Task(void) //////////////////////////////////////////////////////////////////////////////////////// // streams helpers -bool CDmrplusProtocol::OnDvHeaderPacketIn(CDvHeaderPacket *Header, const CIp &Ip) +void CDmrplusProtocol::OnDvHeaderPacketIn(std::unique_ptr &Header, const CIp &Ip) { - bool newstream = false; - // find the stream CPacketStream *stream = GetStream(Header->GetStreamId()); if ( stream == nullptr ) @@ -222,7 +199,6 @@ bool CDmrplusProtocol::OnDvHeaderPacketIn(CDvHeaderPacket *Header, const CIp &Ip { // keep the handle m_Streams.push_back(stream); - newstream = true; } } // release @@ -233,23 +209,11 @@ bool CDmrplusProtocol::OnDvHeaderPacketIn(CDvHeaderPacket *Header, const CIp &Ip // stream already open // skip packet, but tickle the stream stream->Tickle(); - // and delete packet - delete Header; } // update last heard g_Reflector.GetUsers()->Hearing(Header->GetMyCallsign(), Header->GetRpt1Callsign(), Header->GetRpt2Callsign()); g_Reflector.ReleaseUsers(); - - // delete header if needed - if ( !newstream ) - { - delete Header; - } - - - // done - return newstream; } //////////////////////////////////////////////////////////////////////////////////////// @@ -262,7 +226,7 @@ void CDmrplusProtocol::HandleQueue(void) while ( !m_Queue.empty() ) { // get the packet - CPacket *packet = m_Queue.front(); + auto packet = m_Queue.front(); m_Queue.pop(); // get our sender's id @@ -330,9 +294,6 @@ void CDmrplusProtocol::HandleQueue(void) // debug //buffer.DebugDump(g_Reflector.m_DebugFile); } - - // done - delete packet; } m_Queue.Unlock(); } @@ -443,11 +404,8 @@ bool CDmrplusProtocol::IsValidDisconnectPacket(const CBuffer &Buffer, CCallsign return valid; } -bool CDmrplusProtocol::IsValidDvHeaderPacket(const CIp &Ip, const CBuffer &Buffer, CDvHeaderPacket **Header) +bool CDmrplusProtocol::IsValidDvHeaderPacket(const CIp &Ip, const CBuffer &Buffer, std::unique_ptr &Header) { - bool valid = false; - *Header = nullptr; - uint8 uiPacketType = Buffer.data()[8]; if ( (Buffer.size() == 72) && ( uiPacketType == 2 ) ) { @@ -472,26 +430,16 @@ bool CDmrplusProtocol::IsValidDvHeaderPacket(const CIp &Ip, const CBuffer &Buffe uint32 uiStreamId = IpToStreamId(Ip); // and packet - *Header = new CDvHeaderPacket(uiSrcId, CCallsign("CQCQCQ"), rpt1, rpt2, uiStreamId, 0, 0); - valid = (*Header)->IsValid(); - if ( !valid ) - { - delete *Header; - *Header = nullptr; - } + Header = std::unique_ptr(new CDvHeaderPacket(uiSrcId, CCallsign("CQCQCQ"), rpt1, rpt2, uiStreamId, 0, 0)); + if (Header && Header->IsValid()) + return true; } } - // done - return valid; + return false; } -bool CDmrplusProtocol::IsValidDvFramePacket(const CIp &Ip, const CBuffer &Buffer, CDvFramePacket **frames) +bool CDmrplusProtocol::IsValidDvFramePacket(const CIp &Ip, const CBuffer &Buffer, std::array, 3> &frames) { - bool valid = false; - frames[0] = nullptr; - frames[1] = nullptr; - frames[2] = nullptr; - uint8 uiPacketType = Buffer.data()[8]; if ( (Buffer.size() == 72) && ((uiPacketType == 1) || (uiPacketType == 3)) ) { @@ -530,30 +478,29 @@ bool CDmrplusProtocol::IsValidDvFramePacket(const CIp &Ip, const CBuffer &Buffer uint32 uiStreamId = IpToStreamId(Ip); // frame1 memcpy(dmrambe, &dmr3ambe[0], 9); - frames[0] = new CDvFramePacket(dmrambe, dmrsync, uiStreamId, uiVoiceSeq, 1); + frames[0] = std::unique_ptr(new CDvFramePacket(dmrambe, dmrsync, uiStreamId, uiVoiceSeq, 1)); // frame2 memcpy(dmrambe, &dmr3ambe[9], 9); - frames[1] = new CDvFramePacket(dmrambe, dmrsync, uiStreamId, uiVoiceSeq, 2); + frames[1] = std::unique_ptr(new CDvFramePacket(dmrambe, dmrsync, uiStreamId, uiVoiceSeq, 2)); // frame3 memcpy(dmrambe, &dmr3ambe[18], 9); if ( uiPacketType == 3 ) { - frames[2] = new CDvLastFramePacket(dmrambe, dmrsync, uiStreamId, uiVoiceSeq, 3); + frames[2] = std::unique_ptr(new CDvLastFramePacket(dmrambe, dmrsync, uiStreamId, uiVoiceSeq, 3)); } else { - frames[2] = new CDvFramePacket(dmrambe, dmrsync, uiStreamId, uiVoiceSeq, 3); + frames[2] = std::unique_ptr(new CDvFramePacket(dmrambe, dmrsync, uiStreamId, uiVoiceSeq, 3)); } // check - valid = true; + if (frames[0] && frames[1] && frames[2]) + return true; } } - - // done - return valid; + return false; } diff --git a/src/cdmrplusprotocol.h b/src/cdmrplusprotocol.h index 51eea96..3884859 100644 --- a/src/cdmrplusprotocol.h +++ b/src/cdmrplusprotocol.h @@ -71,13 +71,13 @@ protected: void HandleKeepalives(void); // stream helpers - bool OnDvHeaderPacketIn(CDvHeaderPacket *, const CIp &); + void OnDvHeaderPacketIn(std::unique_ptr &, const CIp &); // packet decoding helpers bool IsValidConnectPacket(const CBuffer &, CCallsign *, char *, const CIp &); bool IsValidDisconnectPacket(const CBuffer &, CCallsign *, char *); - bool IsValidDvHeaderPacket(const CIp &, const CBuffer &, CDvHeaderPacket **); - bool IsValidDvFramePacket(const CIp &, const CBuffer &, CDvFramePacket **); + bool IsValidDvHeaderPacket(const CIp &, const CBuffer &, std::unique_ptr &); + bool IsValidDvFramePacket(const CIp &, const CBuffer &, std::array, 3> &); // packet encoding helpers void EncodeConnectAckPacket(CBuffer *); diff --git a/src/cdplusprotocol.cpp b/src/cdplusprotocol.cpp index b2a35a8..19efcbf 100644 --- a/src/cdplusprotocol.cpp +++ b/src/cdplusprotocol.cpp @@ -57,9 +57,9 @@ void CDplusProtocol::Task(void) CBuffer Buffer; CIp Ip; CCallsign Callsign; - CDvHeaderPacket *Header; - CDvFramePacket *Frame; - CDvLastFramePacket *LastFrame; + std::unique_ptr Header; + std::unique_ptr Frame; + std::unique_ptr LastFrame; // handle incoming packets #if DSTAR_IPV6==true @@ -73,33 +73,21 @@ void CDplusProtocol::Task(void) #endif { // crack the packet - if ( (Frame = IsValidDvFramePacket(Buffer)) != nullptr ) + if ( IsValidDvFramePacket(Buffer, Frame) ) { - //std::cout << "DPlus DV frame" << std::endl; - - // handle it OnDvFramePacketIn(Frame, &Ip); } - else if ( (Header = IsValidDvHeaderPacket(Buffer)) != nullptr ) + else if ( IsValidDvHeaderPacket(Buffer, Header) ) { - //std::cout << "DPlus DV header:" << std::endl << *Header << std::endl; - - // callsign muted? + // is muted? if ( g_GateKeeper.MayTransmit(Header->GetMyCallsign(), Ip, PROTOCOL_DPLUS, Header->GetRpt2Module()) ) { // handle it OnDvHeaderPacketIn(Header, Ip); } - else - { - delete Header; - } } - else if ( (LastFrame = IsValidDvLastFramePacket(Buffer)) != nullptr ) + else if ( IsValidDvLastFramePacket(Buffer, LastFrame) ) { - //std::cout << "DPlus DV last frame" << std::endl; - - // handle it OnDvLastFramePacketIn(LastFrame, &Ip); } else if ( IsValidConnectPacket(Buffer) ) @@ -189,10 +177,8 @@ void CDplusProtocol::Task(void) //////////////////////////////////////////////////////////////////////////////////////// // streams helpers -bool CDplusProtocol::OnDvHeaderPacketIn(CDvHeaderPacket *Header, const CIp &Ip) +void CDplusProtocol::OnDvHeaderPacketIn(std::unique_ptr &Header, const CIp &Ip) { - bool newstream = false; - // find the stream CPacketStream *stream = GetStream(Header->GetStreamId()); if ( stream == nullptr ) @@ -224,7 +210,6 @@ bool CDplusProtocol::OnDvHeaderPacketIn(CDvHeaderPacket *Header, const CIp &Ip) { // keep the handle m_Streams.push_back(stream); - newstream = true; } } // release @@ -233,12 +218,6 @@ bool CDplusProtocol::OnDvHeaderPacketIn(CDvHeaderPacket *Header, const CIp &Ip) // update last heard g_Reflector.GetUsers()->Hearing(Header->GetMyCallsign(), via, Header->GetRpt2Callsign()); g_Reflector.ReleaseUsers(); - - // delete header if needed - if ( !newstream ) - { - delete Header; - } } else { @@ -250,12 +229,7 @@ bool CDplusProtocol::OnDvHeaderPacketIn(CDvHeaderPacket *Header, const CIp &Ip) // stream already open // skip packet, but tickle the stream stream->Tickle(); - // and delete packet - delete Header; } - - // done - return newstream; } //////////////////////////////////////////////////////////////////////////////////////// @@ -267,7 +241,7 @@ void CDplusProtocol::HandleQueue(void) while ( !m_Queue.empty() ) { // get the packet - CPacket *packet = m_Queue.front(); + auto packet = m_Queue.front(); m_Queue.pop(); // get our sender's id @@ -302,7 +276,7 @@ void CDplusProtocol::HandleQueue(void) if ( packet->IsDvHeader() ) { // sending header in Dplus is client specific - SendDvHeader((CDvHeaderPacket *)packet, (CDplusClient *)client.get()); + SendDvHeader((CDvHeaderPacket *)packet.get(), (CDplusClient *)client.get()); } else if ( packet->IsDvFrame() ) { @@ -327,10 +301,6 @@ void CDplusProtocol::HandleQueue(void) } g_Reflector.ReleaseClients(); } - - - // done - delete packet; } m_Queue.Unlock(); } @@ -447,70 +417,43 @@ bool CDplusProtocol::IsValidKeepAlivePacket(const CBuffer &Buffer) return (Buffer == CBuffer(tag, sizeof(tag))); } -CDvHeaderPacket *CDplusProtocol::IsValidDvHeaderPacket(const CBuffer &Buffer) +bool CDplusProtocol::IsValidDvHeaderPacket(const CBuffer &Buffer, std::unique_ptr &header) { - CDvHeaderPacket *header = nullptr; - - if ( (Buffer.size() == 58) && - (Buffer.data()[0] == 0x3A) && (Buffer.data()[1] == 0x80) && - (Buffer.Compare((uint8 *)"DSVT", 2, 4) == 0) && - (Buffer.data()[6] == 0x10) && (Buffer.data()[10] == 0x20) ) + if ( 58==Buffer.size() && 0x3AU==Buffer.data()[0] && 0x80U==Buffer.data()[1] && 0==Buffer.Compare((uint8 *)"DSVT", 2, 4) && 0x10U==Buffer.data()[6] && 0x20U==Buffer.data()[10] ) { // create packet - header = new CDvHeaderPacket((struct dstar_header *)&(Buffer.data()[17]), - *((uint16 *)&(Buffer.data()[14])), 0x80); + header = std::unique_ptr(new CDvHeaderPacket((struct dstar_header *)&(Buffer.data()[17]), *((uint16 *)&(Buffer.data()[14])), 0x80)); // check validity of packet - if ( !header->IsValid() ) - { - delete header; - header = nullptr; - } + if ( header && header->IsValid() ) + return true; } - return header; + return false; } -CDvFramePacket *CDplusProtocol::IsValidDvFramePacket(const CBuffer &Buffer) +bool CDplusProtocol::IsValidDvFramePacket(const CBuffer &Buffer, std::unique_ptr &dvframe) { - CDvFramePacket *dvframe = nullptr; - - if ( (Buffer.size() == 29) && - (Buffer.data()[0] == 0x1D) && (Buffer.data()[1] == 0x80) && - (Buffer.Compare((uint8 *)"DSVT", 2, 4) == 0) && - (Buffer.data()[6] == 0x20) && (Buffer.data()[10] == 0x20) ) + if ( 29==Buffer.size() && 0x1DU==Buffer.data()[0] && 0x80U==Buffer.data()[1] && 0==Buffer.Compare((uint8 *)"DSVT", 2, 4) && 0x20U==Buffer.data()[6] && 0x20U==Buffer.data()[10] ) { // create packet - dvframe = new CDvFramePacket((struct dstar_dvframe *)&(Buffer.data()[17]), - *((uint16 *)&(Buffer.data()[14])), Buffer.data()[16]); + dvframe = std::unique_ptr(new CDvFramePacket((struct dstar_dvframe *)&(Buffer.data()[17]), *((uint16 *)&(Buffer.data()[14])), Buffer.data()[16])); // check validity of packet - if ( !dvframe->IsValid() ) - { - delete dvframe; - dvframe = nullptr; - } + if ( dvframe && dvframe->IsValid() ) + return true; } - return dvframe; + return false; } -CDvLastFramePacket *CDplusProtocol::IsValidDvLastFramePacket(const CBuffer &Buffer) +bool CDplusProtocol::IsValidDvLastFramePacket(const CBuffer &Buffer, std::unique_ptr &dvframe) { - CDvLastFramePacket *dvframe = nullptr; - - if ( (Buffer.size() == 32) && - (Buffer.Compare((uint8 *)"DSVT", 2, 4) == 0) && - (Buffer.data()[0] == 0x20) && (Buffer.data()[1] == 0x80) && - (Buffer.data()[6] == 0x20) && (Buffer.data()[10] == 0x20) ) + if ( 32==Buffer.size() && 0==Buffer.Compare((uint8 *)"DSVT", 2, 4) && 0x20U==Buffer.data()[0] && 0x80U==Buffer.data()[1] && 0x20U==Buffer.data()[6] && 0x20U==Buffer.data()[10] ) { // create packet - dvframe = new CDvLastFramePacket((struct dstar_dvframe *)&(Buffer.data()[17]), - *((uint16 *)&(Buffer.data()[14])), Buffer.data()[16]); + dvframe = std::unique_ptr(new CDvLastFramePacket((struct dstar_dvframe *)&(Buffer.data()[17]), *((uint16 *)&(Buffer.data()[14])), Buffer.data()[16])); // check validity of packet - if ( !dvframe->IsValid() ) - { - delete dvframe; - dvframe = nullptr; - } + if ( dvframe && dvframe->IsValid() ) + return true; } - return dvframe; + return false; } diff --git a/src/cdplusprotocol.h b/src/cdplusprotocol.h index 0515946..79af739 100644 --- a/src/cdplusprotocol.h +++ b/src/cdplusprotocol.h @@ -66,25 +66,25 @@ protected: void HandleKeepalives(void); // stream helpers - bool OnDvHeaderPacketIn(CDvHeaderPacket *, const CIp &); + void OnDvHeaderPacketIn(std::unique_ptr &, const CIp &); // packet decoding helpers - bool IsValidConnectPacket(const CBuffer &); - bool IsValidLoginPacket(const CBuffer &, CCallsign *); - bool IsValidDisconnectPacket(const CBuffer &); - bool IsValidKeepAlivePacket(const CBuffer &); - CDvHeaderPacket *IsValidDvHeaderPacket(const CBuffer &); - CDvFramePacket *IsValidDvFramePacket(const CBuffer &); - CDvLastFramePacket *IsValidDvLastFramePacket(const CBuffer &); + bool IsValidConnectPacket(const CBuffer &); + bool IsValidLoginPacket(const CBuffer &, CCallsign *); + bool IsValidDisconnectPacket(const CBuffer &); + bool IsValidKeepAlivePacket(const CBuffer &); + bool IsValidDvHeaderPacket(const CBuffer &, std::unique_ptr &); + bool IsValidDvFramePacket(const CBuffer &, std::unique_ptr &); + bool IsValidDvLastFramePacket(const CBuffer &, std::unique_ptr &); // packet encoding helpers - void EncodeKeepAlivePacket(CBuffer *); - void EncodeLoginAckPacket(CBuffer *); - void EncodeLoginNackPacket(CBuffer *); - void EncodeDisconnectPacket(CBuffer *); - bool EncodeDvHeaderPacket(const CDvHeaderPacket &, CBuffer *) const; - bool EncodeDvFramePacket(const CDvFramePacket &, CBuffer *) const; - bool EncodeDvLastFramePacket(const CDvLastFramePacket &, CBuffer *) const; + void EncodeKeepAlivePacket(CBuffer *); + void EncodeLoginAckPacket(CBuffer *); + void EncodeLoginNackPacket(CBuffer *); + void EncodeDisconnectPacket(CBuffer *); + bool EncodeDvHeaderPacket(const CDvHeaderPacket &, CBuffer *) const; + bool EncodeDvFramePacket(const CDvFramePacket &, CBuffer *) const; + bool EncodeDvLastFramePacket(const CDvLastFramePacket &, CBuffer *) const; protected: diff --git a/src/cdvframepacket.cpp b/src/cdvframepacket.cpp index 0189b1c..345e090 100644 --- a/src/cdvframepacket.cpp +++ b/src/cdvframepacket.cpp @@ -95,9 +95,9 @@ CDvFramePacket::CDvFramePacket //////////////////////////////////////////////////////////////////////////////////////// // virtual duplication -CPacket *CDvFramePacket::Duplicate(void) const +std::unique_ptr CDvFramePacket::Duplicate(void) const { - return new CDvFramePacket(*this); + return std::unique_ptr(new CDvFramePacket(*this)); } //////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/cdvframepacket.h b/src/cdvframepacket.h index dbeb7df..a38f1b2 100644 --- a/src/cdvframepacket.h +++ b/src/cdvframepacket.h @@ -61,7 +61,7 @@ public: #endif // virtual duplication - CPacket *Duplicate(void) const; + std::unique_ptr Duplicate(void) const; // identity bool IsDvFrame(void) const { return true; } diff --git a/src/cdvheaderpacket.cpp b/src/cdvheaderpacket.cpp index df15628..5407d9f 100644 --- a/src/cdvheaderpacket.cpp +++ b/src/cdvheaderpacket.cpp @@ -90,9 +90,9 @@ CDvHeaderPacket::CDvHeaderPacket(const CCallsign &my, const CCallsign &ur, const //////////////////////////////////////////////////////////////////////////////////////// // virtual duplication -CPacket *CDvHeaderPacket::Duplicate(void) const +std::unique_ptr CDvHeaderPacket::Duplicate(void) const { - return new CDvHeaderPacket(*this); + return std::unique_ptr(new CDvHeaderPacket(*this)); } //////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/cdvheaderpacket.h b/src/cdvheaderpacket.h index dff33b1..9f1f053 100644 --- a/src/cdvheaderpacket.h +++ b/src/cdvheaderpacket.h @@ -68,7 +68,7 @@ public: #endif // virtual duplication - CPacket *Duplicate(void) const; + std::unique_ptr Duplicate(void) const; // identity bool IsDvHeader(void) const { return true; } diff --git a/src/cdvlastframepacket.cpp b/src/cdvlastframepacket.cpp index 06731cd..c9c77e9 100644 --- a/src/cdvlastframepacket.cpp +++ b/src/cdvlastframepacket.cpp @@ -77,7 +77,7 @@ CDvLastFramePacket::CDvLastFramePacket(const CDvLastFramePacket &DvFrame) //////////////////////////////////////////////////////////////////////////////////////// // virtual duplication -CPacket *CDvLastFramePacket::Duplicate(void) const +std::unique_ptr CDvLastFramePacket::Duplicate(void) const { - return new CDvLastFramePacket(*this); + return std::unique_ptr(new CDvLastFramePacket(*this)); } diff --git a/src/cdvlastframepacket.h b/src/cdvlastframepacket.h index ba068fb..3eca1b3 100644 --- a/src/cdvlastframepacket.h +++ b/src/cdvlastframepacket.h @@ -49,7 +49,7 @@ public: CDvLastFramePacket(const CDvLastFramePacket &); // virtual duplication - CPacket *Duplicate(void) const; + std::unique_ptr Duplicate(void) const; // identity bool IsLastPacket(void) const { return true; } diff --git a/src/cg3protocol.cpp b/src/cg3protocol.cpp index 13f08d6..fb98765 100644 --- a/src/cg3protocol.cpp +++ b/src/cg3protocol.cpp @@ -372,14 +372,14 @@ void CG3Protocol::IcmpTask(void) void CG3Protocol::Task(void) { - CBuffer Buffer; - CIp Ip; - CCallsign Callsign; - char ToLinkModule; - int ProtRev; - CDvHeaderPacket *Header; - CDvFramePacket *Frame; - CDvLastFramePacket *LastFrame; + CBuffer Buffer; + CIp Ip; + CCallsign Callsign; + char ToLinkModule; + int ProtRev; + std::unique_ptr Header; + std::unique_ptr Frame; + std::unique_ptr LastFrame; // any incoming packet ? if ( m_Socket4.Receive(Buffer, Ip, 20) ) @@ -407,44 +407,23 @@ void CG3Protocol::Task(void) if (BaseIp != nullptr) { // crack the packet - if ( (Frame = IsValidDvFramePacket(Buffer)) != nullptr ) + if ( IsValidDvFramePacket(Buffer, Frame) ) { - //std::cout << "Terminal DV frame" << std::endl; - - // handle it OnDvFramePacketIn(Frame, BaseIp); } - else if ( (Header = IsValidDvHeaderPacket(Buffer)) != nullptr ) + else if ( IsValidDvHeaderPacket(Buffer, Header) ) { - //std::cout << "Terminal DV header" << std::endl; - // callsign muted? if ( g_GateKeeper.MayTransmit(Header->GetMyCallsign(), Ip, PROTOCOL_G3, Header->GetRpt2Module()) ) { // handle it OnDvHeaderPacketIn(Header, *BaseIp); } - else - { - delete Header; - } } - else if ( (LastFrame = IsValidDvLastFramePacket(Buffer)) != nullptr ) + else if ( IsValidDvLastFramePacket(Buffer, LastFrame) ) { - //std::cout << "Terminal DV last frame" << std::endl; - - // handle it OnDvLastFramePacketIn(LastFrame, BaseIp); } - else - { - //std::cout << "Invalid terminal packet (" << Buffer.size() << ")" << std::endl; - //std::cout << Buffer.data() << std::endl; - } - } - else - { - //std::cout << "Invalid client " << Ip << std::endl; } } @@ -480,7 +459,7 @@ void CG3Protocol::HandleQueue(void) m_LastKeepaliveTime.Now(); // get the packet - CPacket *packet = m_Queue.front(); + auto packet = m_Queue.front(); m_Queue.pop(); // encode it @@ -506,9 +485,6 @@ void CG3Protocol::HandleQueue(void) } g_Reflector.ReleaseClients(); } - - // done - delete packet; } m_Queue.Unlock(); } @@ -545,10 +521,8 @@ void CG3Protocol::HandleKeepalives(void) //////////////////////////////////////////////////////////////////////////////////////// // streams helpers -bool CG3Protocol::OnDvHeaderPacketIn(CDvHeaderPacket *Header, const CIp &Ip) +void CG3Protocol::OnDvHeaderPacketIn(std::unique_ptr &Header, const CIp &Ip) { - bool newstream = false; - // find the stream CPacketStream *stream = GetStream(Header->GetStreamId(), &Ip); @@ -585,10 +559,8 @@ bool CG3Protocol::OnDvHeaderPacketIn(CDvHeaderPacket *Header, const CIp &Ip) } else { - // drop if invalid module - delete Header; g_Reflector.ReleaseClients(); - return false; + return; } } @@ -600,24 +572,11 @@ bool CG3Protocol::OnDvHeaderPacketIn(CDvHeaderPacket *Header, const CIp &Ip) { // keep the handle m_Streams.push_back(stream); - newstream = true; } // update last heard g_Reflector.GetUsers()->Hearing(Header->GetMyCallsign(), via, Header->GetRpt2Callsign()); g_Reflector.ReleaseUsers(); - - // delete header if needed - if ( !newstream ) - { - delete Header; - } - - } - else - { - // drop - delete Header; } } // release @@ -628,120 +587,92 @@ bool CG3Protocol::OnDvHeaderPacketIn(CDvHeaderPacket *Header, const CIp &Ip) // stream already open // skip packet, but tickle the stream stream->Tickle(); - // and delete packet - delete Header; } - - // done - return newstream; } //////////////////////////////////////////////////////////////////////////////////////// // packet decoding helpers -CDvHeaderPacket *CG3Protocol::IsValidDvHeaderPacket(const CBuffer &Buffer) +bool CG3Protocol::IsValidDvHeaderPacket(const CBuffer &Buffer, std::unique_ptr &header) { - CDvHeaderPacket *header = nullptr; - - if ( (Buffer.size() == 56) && (Buffer.Compare((uint8 *)"DSVT", 4) == 0) && - (Buffer.data()[4] == 0x10) && (Buffer.data()[8] == 0x20) ) + if ( 56==Buffer.size() && 0==Buffer.Compare((uint8 *)"DSVT", 4) && 0x10U==Buffer.data()[4] && 0x20U==Buffer.data()[8] ) { // create packet - header = new CDvHeaderPacket((struct dstar_header *)&(Buffer.data()[15]), - *((uint16 *)&(Buffer.data()[12])), 0x80); + header = std::unique_ptr(new CDvHeaderPacket((struct dstar_header *)&(Buffer.data()[15]), *((uint16 *)&(Buffer.data()[12])), 0x80)); // check validity of packet - if ( !header->IsValid() ) - { - delete header; - header = nullptr; - } + if ( header && header->IsValid() ) + return true; } - return header; + return false; } -CDvFramePacket *CG3Protocol::IsValidDvFramePacket(const CBuffer &Buffer) +bool CG3Protocol::IsValidDvFramePacket(const CBuffer &Buffer, std::unique_ptr &dvframe) { - CDvFramePacket *dvframe = nullptr; - - if ( (Buffer.size() == 27) && (Buffer.Compare((uint8 *)"DSVT", 4) == 0) && - (Buffer.data()[4] == 0x20) && (Buffer.data()[8] == 0x20) && - ((Buffer.data()[14] & 0x40) == 0) ) + if ( 27==Buffer.size() && 0==Buffer.Compare((uint8 *)"DSVT", 4) && 0x20U==Buffer.data()[4] && 0x20U==Buffer.data()[8] && 0U==(Buffer.data()[14] & 0x40U) ) { // create packet - dvframe = new CDvFramePacket((struct dstar_dvframe *)&(Buffer.data()[15]), - *((uint16 *)&(Buffer.data()[12])), Buffer.data()[14]); + dvframe = std::unique_ptr(new CDvFramePacket((struct dstar_dvframe *)&(Buffer.data()[15]), *((uint16 *)&(Buffer.data()[12])), Buffer.data()[14])); // check validity of packet - if ( !dvframe->IsValid() ) - { - delete dvframe; - dvframe = nullptr; - } + if ( dvframe && dvframe->IsValid() ) + return true; } - return dvframe; + return false; } -CDvLastFramePacket *CG3Protocol::IsValidDvLastFramePacket(const CBuffer &Buffer) +bool CG3Protocol::IsValidDvLastFramePacket(const CBuffer &Buffer, std::unique_ptr &dvframe) { - CDvLastFramePacket *dvframe = nullptr; - - if ( (Buffer.size() == 27) && (Buffer.Compare((uint8 *)"DSVT", 4) == 0) && - (Buffer.data()[4] == 0x20) && (Buffer.data()[8] == 0x20) && - ((Buffer.data()[14] & 0x40) != 0) ) + if ( 27==Buffer.size() && 0==Buffer.Compare((uint8 *)"DSVT", 4) && 0x20U==Buffer.data()[4] && 0x20U==Buffer.data()[8] && (Buffer.data()[14] & 0x40U) ) { // create packet - dvframe = new CDvLastFramePacket((struct dstar_dvframe *)&(Buffer.data()[15]), - *((uint16 *)&(Buffer.data()[12])), Buffer.data()[14]); + dvframe = std::unique_ptr(new CDvLastFramePacket((struct dstar_dvframe *)&(Buffer.data()[15]), *((uint16 *)&(Buffer.data()[12])), Buffer.data()[14])); // check validity of packet - if ( !dvframe->IsValid() ) - { - delete dvframe; - dvframe = nullptr; - } + if ( dvframe && dvframe->IsValid() ) + return true; } - return dvframe; + return false; } //////////////////////////////////////////////////////////////////////////////////////// // packet encoding helpers -bool CG3Protocol::EncodeDvHeaderPacket(const CDvHeaderPacket &Packet, CBuffer *Buffer) const +bool CG3Protocol::EncodeDvHeaderPacket(const std::unique_ptr &Packet, CBuffer *Buffer) const { uint8 tag[] = { 'D','S','V','T',0x10,0x00,0x00,0x00,0x20,0x00,0x01,0x02 }; struct dstar_header DstarHeader; - Packet.ConvertToDstarStruct(&DstarHeader); + Packet->ConvertToDstarStruct(&DstarHeader); Buffer->Set(tag, sizeof(tag)); - Buffer->Append(Packet.GetStreamId()); + Buffer->Append(Packet->GetStreamId()); Buffer->Append((uint8)0x80); Buffer->Append((uint8 *)&DstarHeader, sizeof(struct dstar_header)); return true; } -bool CG3Protocol::EncodeDvFramePacket(const CDvFramePacket &Packet, CBuffer *Buffer) const +bool CG3Protocol::EncodeDvFramePacket(const std::unique_ptr &Packet, CBuffer *Buffer) const { uint8 tag[] = { 'D','S','V','T',0x20,0x00,0x00,0x00,0x20,0x00,0x01,0x02 }; Buffer->Set(tag, sizeof(tag)); - Buffer->Append(Packet.GetStreamId()); - Buffer->Append((uint8)(Packet.GetPacketId() % 21)); - Buffer->Append((uint8 *)Packet.GetAmbe(), AMBE_SIZE); - Buffer->Append((uint8 *)Packet.GetDvData(), DVDATA_SIZE); + Buffer->Append(Packet->GetStreamId()); + Buffer->Append((uint8)(Packet->GetPacketId() % 21)); + Buffer->Append((uint8 *)Packet->GetAmbe(), AMBE_SIZE); + Buffer->Append((uint8 *)Packet->GetDvData(), DVDATA_SIZE); return true; } -bool CG3Protocol::EncodeDvLastFramePacket(const CDvLastFramePacket &Packet, CBuffer *Buffer) const +bool CG3Protocol::EncodeDvLastFramePacket(const std::unique_ptr &Packet, CBuffer *Buffer) const { uint8 tag1[] = { 'D','S','V','T',0x20,0x00,0x00,0x00,0x20,0x00,0x01,0x02 }; uint8 tag2[] = { 0x55,0xC8,0x7A,0x00,0x00,0x00,0x00,0x00,0x00,0x25,0x1A,0xC6 }; Buffer->Set(tag1, sizeof(tag1)); - Buffer->Append(Packet.GetStreamId()); - Buffer->Append((uint8)((Packet.GetPacketId() % 21) | 0x40)); + Buffer->Append(Packet->GetStreamId()); + Buffer->Append((uint8)((Packet->GetPacketId() % 21) | 0x40)); Buffer->Append(tag2, sizeof(tag2)); return true; diff --git a/src/cg3protocol.h b/src/cg3protocol.h index 01e4bba..fe21fd8 100644 --- a/src/cg3protocol.h +++ b/src/cg3protocol.h @@ -100,22 +100,20 @@ protected: void HandleKeepalives(void); // stream helpers - bool OnDvHeaderPacketIn(CDvHeaderPacket *, const CIp &); + void OnDvHeaderPacketIn(std::unique_ptr &, const CIp &); // packet decoding helpers - CDvHeaderPacket *IsValidDvHeaderPacket(const CBuffer &); - CDvFramePacket *IsValidDvFramePacket(const CBuffer &); - CDvLastFramePacket *IsValidDvLastFramePacket(const CBuffer &); + bool IsValidDvHeaderPacket(const CBuffer &, std::unique_ptr &); + bool IsValidDvFramePacket(const CBuffer &, std::unique_ptr &); + bool IsValidDvLastFramePacket(const CBuffer &, std::unique_ptr &); // packet encoding helpers - bool EncodeDvHeaderPacket(const CDvHeaderPacket &, CBuffer *) const; - bool EncodeDvFramePacket(const CDvFramePacket &, CBuffer *) const; - bool EncodeDvLastFramePacket(const CDvLastFramePacket &, CBuffer *) const; + bool EncodeDvHeaderPacket(const std::unique_ptr &, CBuffer *) const; + bool EncodeDvFramePacket(const std::unique_ptr &, CBuffer *) const; + bool EncodeDvLastFramePacket(const std::unique_ptr &, CBuffer *) const; protected: - std::future m_PresenceFuture; - std::future m_ConfigFuture; - std::future m_IcmpFuture; + std::future m_PresenceFuture, m_ConfigFuture, m_IcmpFuture; // time CTimePoint m_LastKeepaliveTime; diff --git a/src/cpacket.h b/src/cpacket.h index a0781ec..6969050 100644 --- a/src/cpacket.h +++ b/src/cpacket.h @@ -49,13 +49,13 @@ public: virtual ~CPacket() {} // virtual duplication - virtual CPacket *Duplicate(void) const = 0; + virtual std::unique_ptr Duplicate(void) const = 0; // identity virtual bool IsDvHeader(void) const { return false; } virtual bool IsDvFrame(void) const { return false; } virtual bool IsLastPacket(void) const { return false; } - virtual bool HasTranscodableAmbe(void) const { return false; } + virtual bool HasTranscodableAmbe(void) const { return false; } // get virtual bool IsValid(void) const { return true; } diff --git a/src/cpacketqueue.h b/src/cpacketqueue.h index 9de49bb..312350a 100644 --- a/src/cpacketqueue.h +++ b/src/cpacketqueue.h @@ -39,30 +39,18 @@ class CClient; class CPacketQueue { public: - // constructor - CPacketQueue() {} - // destructor - ~CPacketQueue() - { - Lock(); - while (! queue.empty()) - { - delete queue.front(); - queue.pop(); - } - Unlock(); - } + virtual ~CPacketQueue() {} // lock void Lock() { m_Mutex.lock(); } void Unlock() { m_Mutex.unlock(); } // pass thru - CPacket *front() { return queue.front(); } - void pop() { queue.pop(); } - void push(CPacket *packet) { queue.push(packet); } - bool empty() const { return queue.empty(); } + void pop() { queue.pop(); } + bool empty() const { return queue.empty(); } + std::unique_ptr front() { return std::move(queue.front()); } + void push(std::unique_ptr &packet) { queue.push(std::move(packet)); } protected: // status @@ -72,7 +60,7 @@ protected: // owner CClient *m_Client; - std::queue queue; + std::queue> queue; }; //////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/cpacketstream.cpp b/src/cpacketstream.cpp index 3e045e5..31384ec 100644 --- a/src/cpacketstream.cpp +++ b/src/cpacketstream.cpp @@ -82,7 +82,7 @@ void CPacketStream::Close(void) //////////////////////////////////////////////////////////////////////////////////////// // push & pop -void CPacketStream::Push(CPacket *Packet) +void CPacketStream::Push(std::unique_ptr Packet) { // update stream dependent packet data m_LastPacketTime.Now(); diff --git a/src/cpacketstream.h b/src/cpacketstream.h index 4707d0e..bc06a73 100644 --- a/src/cpacketstream.h +++ b/src/cpacketstream.h @@ -44,15 +44,12 @@ public: // constructor CPacketStream(); - // destructor - virtual ~CPacketStream() {} - // open / close bool Open(const CDvHeaderPacket &, std::shared_ptr); void Close(void); // push & pop - void Push(CPacket *); + void Push(std::unique_ptr packet); void Tickle(void) { m_LastPacketTime.Now(); } bool IsEmpty(void) const; diff --git a/src/cprotocol.cpp b/src/cprotocol.cpp index e72e2f2..ece157e 100644 --- a/src/cprotocol.cpp +++ b/src/cprotocol.cpp @@ -162,39 +162,37 @@ bool CProtocol::EncodeDvPacket(const CPacket &packet, CBuffer *buffer) const //////////////////////////////////////////////////////////////////////////////////////// // streams helpers -void CProtocol::OnDvFramePacketIn(CDvFramePacket *Frame, const CIp *Ip) +void CProtocol::OnDvFramePacketIn(std::unique_ptr &Frame, const CIp *Ip) { // find the stream CPacketStream *stream = GetStream(Frame->GetStreamId(), Ip); if ( stream == nullptr ) { - std::cout << "Deleting orphaned Frame with ID " << Frame->GetStreamId() << " on " << *Ip << std::endl; - delete Frame; + std::cout << "Orphaned Frame with ID " << Frame->GetStreamId() << " on " << *Ip << std::endl; } else { //std::cout << "DV frame" << "from " << *Ip << std::endl; // and push stream->Lock(); - stream->Push(Frame); + stream->Push(std::move(Frame)); stream->Unlock(); } } -void CProtocol::OnDvLastFramePacketIn(CDvLastFramePacket *Frame, const CIp *Ip) +void CProtocol::OnDvLastFramePacketIn(std::unique_ptr &Frame, const CIp *Ip) { // find the stream CPacketStream *stream = GetStream(Frame->GetStreamId(), Ip); if ( stream == nullptr ) { - std::cout << "Deleting orphaned Last Frame with ID " << Frame->GetStreamId() << " on " << *Ip << std::endl; - delete Frame; + std::cout << "Orphaned Last Frame with ID " << Frame->GetStreamId() << " on " << *Ip << std::endl; } else { // push stream->Lock(); - stream->Push(Frame); + stream->Push(std::move(Frame)); stream->Unlock(); // and close the stream @@ -246,21 +244,6 @@ void CProtocol::CheckStreamsTimeout(void) } } -//////////////////////////////////////////////////////////////////////////////////////// -// queue helper - -void CProtocol::HandleQueue(void) -{ - // the default protocol just keep queue empty - m_Queue.Lock(); - while ( !m_Queue.empty() ) - { - delete m_Queue.front(); - m_Queue.pop(); - } - m_Queue.Unlock(); -} - //////////////////////////////////////////////////////////////////////////////////////// // syntax helper diff --git a/src/cprotocol.h b/src/cprotocol.h index fd1648f..a17ada8 100644 --- a/src/cprotocol.h +++ b/src/cprotocol.h @@ -99,19 +99,19 @@ protected: virtual bool EncodeDvLastFramePacket(const CDvLastFramePacket &, CBuffer *) const { return false; } // stream helpers - virtual bool OnDvHeaderPacketIn(CDvHeaderPacket *, const CIp &) { return false; } - virtual void OnDvFramePacketIn(CDvFramePacket *, const CIp * = nullptr); - virtual void OnDvLastFramePacketIn(CDvLastFramePacket *, const CIp * = nullptr); + virtual void OnDvHeaderPacketIn(std::unique_ptr &, const CIp &) {} + virtual void OnDvFramePacketIn(std::unique_ptr &, const CIp * = nullptr); + virtual void OnDvLastFramePacketIn(std::unique_ptr &, const CIp * = nullptr); // stream handle helpers CPacketStream *GetStream(uint16, const CIp * = nullptr); void CheckStreamsTimeout(void); // queue helper - virtual void HandleQueue(void); + virtual void HandleQueue(void) = 0; // keepalive helpers - virtual void HandleKeepalives(void) {} + virtual void HandleKeepalives(void) = 0; // syntax helper bool IsNumber(char) const; diff --git a/src/creflector.cpp b/src/creflector.cpp index 626a91b..1cbe421 100644 --- a/src/creflector.cpp +++ b/src/creflector.cpp @@ -178,65 +178,54 @@ bool CReflector::IsStreaming(char module) return false; } -CPacketStream *CReflector::OpenStream(CDvHeaderPacket *DvHeader, std::shared_ptrclient) +// clients MUST have bee locked by the caller so we can freely access it within the fuction +CPacketStream *CReflector::OpenStream(std::unique_ptr &DvHeader, std::shared_ptrclient) { - CPacketStream *retStream = nullptr; + // check sid is not zero + if ( 0U == DvHeader->GetStreamId() ) + return nullptr; - // clients MUST have bee locked by the caller - // so we can freely access it within the fuction + // check if client is valid candidate + if ( ! m_Clients.IsClient(client) || client->IsAMaster() ) + return nullptr; - // check sid is not nullptr - if ( DvHeader->GetStreamId() != 0 ) + // check if no stream with same streamid already open + // to prevent loops + if ( IsStreamOpen(DvHeader) ) { - // check if client is valid candidate - if ( m_Clients.IsClient(client) && !client->IsAMaster() ) - { - // check if no stream with same streamid already open - // to prevent loops - if ( !IsStreamOpen(DvHeader) ) - { - // get the module's queue - char module = DvHeader->GetRpt2Module(); - CPacketStream *stream = GetStream(module); - if ( stream != nullptr ) - { - // lock it - stream->Lock(); - // is it available ? - if ( stream->Open(*DvHeader, client) ) - { - // stream open, mark client as master - // so that it can't be deleted - client->SetMasterOfModule(module); - - // update last heard time - client->Heard(); - retStream = stream; - - // and push header packet - stream->Push(DvHeader); - - // report - std::cout << "Opening stream on module " << module << " for client " << client->GetCallsign() << " with sid " << DvHeader->GetStreamId() << " by user " << DvHeader->GetMyCallsign() << std::endl; - - // notify - g_Reflector.OnStreamOpen(stream->GetUserCallsign()); - - } - // unlock now - stream->Unlock(); - } - } - else - { - // report - std::cerr << "Detected stream loop on module " << DvHeader->GetRpt2Module() << " for client " << client->GetCallsign() << " with sid " << DvHeader->GetStreamId() << std::endl; - } - } + std::cerr << "Detected stream loop on module " << DvHeader->GetRpt2Module() << " for client " << client->GetCallsign() << " with sid " << DvHeader->GetStreamId() << std::endl; + return nullptr; } - // done - return retStream; + // get the module's queue + char module = DvHeader->GetRpt2Module(); + CPacketStream *stream = GetStream(module); + if ( stream = nullptr ) + return nullptr; + + stream->Lock(); + // is it available ? + if ( stream->Open(*DvHeader, client) ) + { + // stream open, mark client as master + // so that it can't be deleted + client->SetMasterOfModule(module); + + // update last heard time + client->Heard(); + + // and push header packet + stream->Push(std::move(DvHeader)); + + // report + std::cout << "Opening stream on module " << module << " for client " << client->GetCallsign() << " with sid " << DvHeader->GetStreamId() << " by user " << DvHeader->GetMyCallsign() << std::endl; + + // notify + g_Reflector.OnStreamOpen(stream->GetUserCallsign()); + + } + stream->Unlock(); + return stream; } void CReflector::CloseStream(CPacketStream *stream) @@ -296,7 +285,7 @@ void CReflector::RouterThread(CPacketStream *streamIn) uint8 uiModuleId = GetStreamModule(streamIn); // get on input queue - CPacket *packet; + std::unique_ptr packet; while (keep_running) { @@ -325,7 +314,7 @@ void CReflector::RouterThread(CPacketStream *streamIn) for ( auto it=m_Protocols.begin(); it!=m_Protocols.end(); it++ ) { // duplicate packet - CPacket *packetClone = packet->Duplicate(); + auto packetClone = packet->Duplicate(); // if packet is header, update RPT2 according to protocol if ( packetClone->IsDvHeader() ) @@ -333,7 +322,7 @@ void CReflector::RouterThread(CPacketStream *streamIn) // get our callsign CCallsign csRPT = (*it)->GetReflectorCallsign(); csRPT.SetModule(GetStreamModule(streamIn)); - ((CDvHeaderPacket *)packetClone)->SetRpt2Callsign(csRPT); + (dynamic_cast(packetClone.get()))->SetRpt2Callsign(csRPT); } // and push it @@ -342,13 +331,9 @@ void CReflector::RouterThread(CPacketStream *streamIn) (*it)->ReleaseQueue(); } m_Protocols.Unlock(); - // done - delete packet; - packet = nullptr; } else { - // wait a bit CTimePoint::TaskSleepFor(10); } } @@ -550,7 +535,7 @@ CPacketStream *CReflector::GetStream(char module) return nullptr; } -bool CReflector::IsStreamOpen(const CDvHeaderPacket *DvHeader) +bool CReflector::IsStreamOpen(const std::unique_ptr &DvHeader) { for ( unsigned i = 0; i < m_Stream.size(); i++ ) { diff --git a/src/creflector.h b/src/creflector.h index 8f46429..8578525 100644 --- a/src/creflector.h +++ b/src/creflector.h @@ -87,7 +87,7 @@ public: void ReleasePeers(void) { m_Peers.Unlock(); } // stream opening & closing - CPacketStream *OpenStream(CDvHeaderPacket *, std::shared_ptr); + CPacketStream *OpenStream(std::unique_ptr &, std::shared_ptr); bool IsStreaming(char); void CloseStream(CPacketStream *); @@ -117,8 +117,8 @@ protected: // streams CPacketStream *GetStream(char); - bool IsStreamOpen(const CDvHeaderPacket *); - char GetStreamModule(CPacketStream *); + bool IsStreamOpen(const std::unique_ptr &); + char GetStreamModule(CPacketStream *); // xml helpers void WriteXmlFile(std::ofstream &); diff --git a/src/cxlxprotocol.cpp b/src/cxlxprotocol.cpp index 7a703a1..dbf9f91 100644 --- a/src/cxlxprotocol.cpp +++ b/src/cxlxprotocol.cpp @@ -53,14 +53,14 @@ bool CXlxProtocol::Initalize(const char *type, const uint16 port, const bool has void CXlxProtocol::Task(void) { - CBuffer Buffer; - CIp Ip; - CCallsign Callsign; - char Modules[27]; - CVersion Version; - CDvHeaderPacket *Header; - CDvFramePacket *Frame; - CDvLastFramePacket *LastFrame; + CBuffer Buffer; + CIp Ip; + CCallsign Callsign; + char Modules[27]; + CVersion Version; + std::unique_ptr Header; + std::unique_ptr Frame; + std::unique_ptr LastFrame; // any incoming packet ? #if XLX_IPV6==true @@ -74,42 +74,25 @@ void CXlxProtocol::Task(void) #endif { // crack the packet - if ( (Frame = IsValidDvFramePacket(Buffer)) != nullptr ) + if ( IsValidDvFramePacket(Buffer, Frame) ) { - //std::cout << "XLX (DExtra) DV frame" << std::endl; - - // handle it OnDvFramePacketIn(Frame, &Ip); } - else if ( (Header = IsValidDvHeaderPacket(Buffer)) != nullptr ) + else if ( IsValidDvHeaderPacket(Buffer, Header) ) { - //std::cout << "XLX (DExtra) DV header:" << std::endl << *Header << std::endl; - //std::cout << "XLX (DExtra) DV header on module " << Header->GetRpt2Module() << std::endl; - - // callsign muted? + // callsign allowed? if ( g_GateKeeper.MayTransmit(Header->GetMyCallsign(), Ip) ) { - // handle it OnDvHeaderPacketIn(Header, Ip); } - else - { - delete Header; - } } - else if ( (LastFrame = IsValidDvLastFramePacket(Buffer)) != nullptr ) + else if ( IsValidDvLastFramePacket(Buffer, LastFrame) ) { - //std::cout << "XLX (DExtra) DV last frame" << std::endl; - - // handle it OnDvLastFramePacketIn(LastFrame, &Ip); } else if ( IsValidConnectPacket(Buffer, &Callsign, Modules, &Version) ) { - std::cout << "XLX (" - << Version.GetMajor() << "." << Version.GetMinor() << "." << Version.GetRevision() - << ") connect packet for modules " << Modules - << " from " << Callsign << " at " << Ip << std::endl; + std::cout << "XLX (" << Version.GetMajor() << "." << Version.GetMinor() << "." << Version.GetRevision() << ") connect packet for modules " << Modules << " from " << Callsign << " at " << Ip << std::endl; // callsign authorized? if ( g_GateKeeper.MayLink(Callsign, Ip, PROTOCOL_XLX, Modules) ) @@ -246,7 +229,7 @@ void CXlxProtocol::HandleQueue(void) while ( !m_Queue.empty() ) { // get the packet - CPacket *packet = m_Queue.front(); + auto packet = m_Queue.front(); m_Queue.pop(); // check if origin of packet is local @@ -301,9 +284,6 @@ void CXlxProtocol::HandleQueue(void) g_Reflector.ReleaseClients(); } } - - // done - delete packet; } m_Queue.Unlock(); } @@ -404,9 +384,8 @@ void CXlxProtocol::HandlePeerLinks(void) //////////////////////////////////////////////////////////////////////////////////////// // streams helpers -bool CXlxProtocol::OnDvHeaderPacketIn(CDvHeaderPacket *Header, const CIp &Ip) +void CXlxProtocol::OnDvHeaderPacketIn(std::unique_ptr &Header, const CIp &Ip) { - bool newstream = false; CCallsign peer; // todo: verify Packet.GetModuleId() is in authorized list of XLX of origin @@ -429,7 +408,6 @@ bool CXlxProtocol::OnDvHeaderPacketIn(CDvHeaderPacket *Header, const CIp &Ip) { // keep the handle m_Streams.push_back(stream); - newstream = true; } // get origin peer = client->GetCallsign(); @@ -447,18 +425,9 @@ bool CXlxProtocol::OnDvHeaderPacketIn(CDvHeaderPacket *Header, const CIp &Ip) // update last heard g_Reflector.GetUsers()->Hearing(Header->GetMyCallsign(), Header->GetRpt1Callsign(), Header->GetRpt2Callsign(), peer); g_Reflector.ReleaseUsers(); - - // delete header if needed - if ( !newstream ) - { - delete Header; - } - - // done - return newstream; } -void CXlxProtocol::OnDvFramePacketIn(CDvFramePacket *DvFrame, const CIp *Ip) +void CXlxProtocol::OnDvFramePacketIn(std::unique_ptr &DvFrame, const CIp *Ip) { // tag packet as remote peer origin DvFrame->SetRemotePeerOrigin(); @@ -467,7 +436,7 @@ void CXlxProtocol::OnDvFramePacketIn(CDvFramePacket *DvFrame, const CIp *Ip) CDextraProtocol::OnDvFramePacketIn(DvFrame, Ip); } -void CXlxProtocol::OnDvLastFramePacketIn(CDvLastFramePacket *DvFrame, const CIp *Ip) +void CXlxProtocol::OnDvLastFramePacketIn(std::unique_ptr &DvFrame, const CIp *Ip) { // tag packet as remote peer origin DvFrame->SetRemotePeerOrigin(); @@ -548,72 +517,54 @@ bool CXlxProtocol::IsValidNackPacket(const CBuffer &Buffer, CCallsign *callsign) return valid; } -CDvFramePacket *CXlxProtocol::IsValidDvFramePacket(const CBuffer &Buffer) +bool CXlxProtocol::IsValidDvFramePacket(const CBuffer &Buffer, std::unique_ptr &dvframe) { - CDvFramePacket *dvframe = nullptr; - // base class first (protocol revision 1 and lower) - dvframe = CDextraProtocol::IsValidDvFramePacket(Buffer); + if (CDextraProtocol::IsValidDvFramePacket(Buffer, dvframe)) + return true; // otherwise try protocol revision 2 - if ( (dvframe == nullptr) && - (Buffer.size() == 45) && (Buffer.Compare((uint8 *)"DSVT", 4) == 0) && - (Buffer.data()[4] == 0x20) && (Buffer.data()[8] == 0x20) && - ((Buffer.data()[14] & 0x40) == 0) ) + if ( 45==Buffer.size() && 0==Buffer.Compare((uint8 *)"DSVT", 4) && 0x20U==Buffer.data()[4] && 0x20U==Buffer.data()[8] && 0==(Buffer.data()[14] & 0x40) ) { // create packet - dvframe = new CDvFramePacket( + dvframe = std::unique_ptr(new CDvFramePacket( // sid *((uint16 *)&(Buffer.data()[12])), // dstar Buffer.data()[14], &(Buffer.data()[15]), &(Buffer.data()[24]), // dmr - Buffer.data()[27], Buffer.data()[28], &(Buffer.data()[29]), &(Buffer.data()[38])); + Buffer.data()[27], Buffer.data()[28], &(Buffer.data()[29]), &(Buffer.data()[38]))); // check validity of packet - if ( !dvframe->IsValid() ) - { - delete dvframe; - dvframe = nullptr; - } + if ( dvframe && dvframe->IsValid() ) + return true; } - - // done - return dvframe; + return false; } -CDvLastFramePacket *CXlxProtocol::IsValidDvLastFramePacket(const CBuffer &Buffer) +bool CXlxProtocol::IsValidDvLastFramePacket(const CBuffer &Buffer, std::unique_ptr &dvframe) { - CDvLastFramePacket *dvframe = nullptr; - // base class first (protocol revision 1 and lower) - dvframe = CDextraProtocol::IsValidDvLastFramePacket(Buffer); + if (CDextraProtocol::IsValidDvLastFramePacket(Buffer, dvframe)) + return true; // otherwise try protocol revision 2 - if ( (dvframe == nullptr) && - (Buffer.size() == 45) && (Buffer.Compare((uint8 *)"DSVT", 4) == 0) && - (Buffer.data()[4] == 0x20) && (Buffer.data()[8] == 0x20) && - ((Buffer.data()[14] & 0x40) != 0) ) + if ( 45==Buffer.size() && 0==Buffer.Compare((uint8 *)"DSVT", 4) && 0x20U==Buffer.data()[4] && 0x20U==Buffer.data()[8] && (Buffer.data()[14] & 0x40U) ) { // create packet - dvframe = new CDvLastFramePacket( + dvframe = std::unique_ptr(new CDvLastFramePacket( // sid *((uint16 *)&(Buffer.data()[12])), // dstar Buffer.data()[14], &(Buffer.data()[15]), &(Buffer.data()[24]), // dmr - Buffer.data()[27], Buffer.data()[28], &(Buffer.data()[29]), &(Buffer.data()[38])); + Buffer.data()[27], Buffer.data()[28], &(Buffer.data()[29]), &(Buffer.data()[38]))); // check validity of packet - if ( !dvframe->IsValid() ) - { - delete dvframe; - dvframe = nullptr; - } + if ( dvframe && dvframe->IsValid() ) + return true; } - - // done - return dvframe; + return false; } //////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/cxlxprotocol.h b/src/cxlxprotocol.h index b05eca7..18805ec 100644 --- a/src/cxlxprotocol.h +++ b/src/cxlxprotocol.h @@ -55,9 +55,9 @@ protected: void HandleKeepalives(void); // stream helpers - bool OnDvHeaderPacketIn(CDvHeaderPacket *, const CIp &); - void OnDvFramePacketIn(CDvFramePacket *, const CIp * = nullptr); - void OnDvLastFramePacketIn(CDvLastFramePacket *, const CIp * = nullptr); + void OnDvHeaderPacketIn(std::unique_ptr &, const CIp &); + void OnDvFramePacketIn(std::unique_ptr &, const CIp * = nullptr); + void OnDvLastFramePacketIn(std::unique_ptr &, const CIp * = nullptr); // packet decoding helpers bool IsValidKeepAlivePacket(const CBuffer &, CCallsign *); @@ -65,8 +65,8 @@ protected: bool IsValidDisconnectPacket(const CBuffer &, CCallsign *); bool IsValidAckPacket(const CBuffer &, CCallsign *, char *, CVersion *); bool IsValidNackPacket(const CBuffer &, CCallsign *); - CDvFramePacket *IsValidDvFramePacket(const CBuffer &); - CDvLastFramePacket *IsValidDvLastFramePacket(const CBuffer &); + bool IsValidDvFramePacket(const CBuffer &, std::unique_ptr &); + bool IsValidDvLastFramePacket(const CBuffer &, std::unique_ptr &); // packet encoding helpers void EncodeKeepAlivePacket(CBuffer *); diff --git a/src/cysfprotocol.cpp b/src/cysfprotocol.cpp index e8e27bf..2892dc7 100644 --- a/src/cysfprotocol.cpp +++ b/src/cysfprotocol.cpp @@ -76,16 +76,18 @@ void CYsfProtocol::Close(void) void CYsfProtocol::Task(void) { - CBuffer Buffer; - CIp Ip; - CCallsign Callsign; - CYSFFICH Fich; - CDvHeaderPacket *Header; - CDvFramePacket *Frames[5]; - CWiresxCmd WiresxCmd; - - int iWiresxCmd; - int iWiresxArg; + int iWiresxCmd; + int iWiresxArg; + CBuffer Buffer; + CIp Ip; + CCallsign Callsign; + CYSFFICH Fich; + CWiresxCmd WiresxCmd; + + std::unique_ptr Header; + std::array, 5> Frames; + std::unique_ptr OneFrame; + std::unique_ptr LastFrame; // handle outgoing packets { @@ -114,23 +116,16 @@ void CYsfProtocol::Task(void) // crack the packet if ( IsValidDvPacket(Buffer, &Fich) ) { - //std::cout << "FN = " << (int)Fich.getFN() << " FT = " << (int)Fich.getFT() << std::endl; if ( IsValidDvFramePacket(Ip, Fich, Buffer, Frames) ) { - //std::cout << "YSF DV frame" << std::endl; - - // handle it OnDvFramePacketIn(Frames[0], &Ip); OnDvFramePacketIn(Frames[1], &Ip); OnDvFramePacketIn(Frames[2], &Ip); OnDvFramePacketIn(Frames[3], &Ip); OnDvFramePacketIn(Frames[4], &Ip); } - else if ( IsValidDvHeaderPacket(Ip, Fich, Buffer, &Header, Frames) ) + else if ( IsValidDvHeaderPacket(Ip, Fich, Buffer, Header, Frames) ) { - //std::cout << "YSF DV header:" << std::endl << *Header << std::endl; - //std::cout << "YSF DV header:" << std::endl; - // node linked and callsign muted? if ( g_GateKeeper.MayTransmit(Header->GetMyCallsign(), Ip, PROTOCOL_YSF, Header->GetRpt2Module()) ) { @@ -139,18 +134,11 @@ void CYsfProtocol::Task(void) //OnDvFramePacketIn(Frames[0], &Ip); //OnDvFramePacketIn(Frames[1], &Ip); } - else - { - delete Header; - } } - else if ( IsValidDvLastFramePacket(Ip, Fich, Buffer, Frames) ) + else if ( IsValidDvLastFramePacket(Ip, Fich, Buffer, OneFrame, LastFrame) ) { - //std::cout << "YSF last DV frame" << std::endl; - - // handle it - OnDvFramePacketIn(Frames[0], &Ip); - OnDvLastFramePacketIn((CDvLastFramePacket *)Frames[1], &Ip); + OnDvFramePacketIn(OneFrame, &Ip); + OnDvLastFramePacketIn(LastFrame, &Ip); } } else if ( IsValidConnectPacket(Buffer, &Callsign) ) @@ -235,10 +223,8 @@ void CYsfProtocol::Task(void) //////////////////////////////////////////////////////////////////////////////////////// // streams helpers -bool CYsfProtocol::OnDvHeaderPacketIn(CDvHeaderPacket *Header, const CIp &Ip) +void CYsfProtocol::OnDvHeaderPacketIn(std::unique_ptr &Header, const CIp &Ip) { - bool newstream = false; - // find the stream CPacketStream *stream = GetStream(Header->GetStreamId()); if ( stream == nullptr ) @@ -260,7 +246,6 @@ bool CYsfProtocol::OnDvHeaderPacketIn(CDvHeaderPacket *Header, const CIp &Ip) { // keep the handle m_Streams.push_back(stream); - newstream = true; } } // release @@ -272,24 +257,13 @@ bool CYsfProtocol::OnDvHeaderPacketIn(CDvHeaderPacket *Header, const CIp &Ip) g_Reflector.GetUsers()->Hearing(Header->GetMyCallsign(), via, Header->GetRpt2Callsign()); g_Reflector.ReleaseUsers(); } - - // delete header if needed - if ( !newstream ) - { - delete Header; - } } else { // stream already open // skip packet, but tickle the stream stream->Tickle(); - // and delete packet - delete Header; } - - // done - return newstream; } //////////////////////////////////////////////////////////////////////////////////////// @@ -302,7 +276,7 @@ void CYsfProtocol::HandleQueue(void) while ( !m_Queue.empty() ) { // get the packet - CPacket *packet = m_Queue.front(); + auto packet = m_Queue.front(); m_Queue.pop(); // get our sender's id @@ -319,7 +293,7 @@ void CYsfProtocol::HandleQueue(void) m_StreamsCache[iModId].m_dvHeader = CDvHeaderPacket((const CDvHeaderPacket &)*packet); // encode it - EncodeDvHeaderPacket((const CDvHeaderPacket &)*packet, &buffer); + EncodeDvHeaderPacket((const CDvHeaderPacket &)*packet.get(), &buffer); } // check if it's a last frame else if ( packet->IsLastPacket() ) @@ -363,9 +337,6 @@ void CYsfProtocol::HandleQueue(void) } g_Reflector.ReleaseClients(); } - - // done - delete packet; } m_Queue.Unlock(); } @@ -438,13 +409,8 @@ bool CYsfProtocol::IsValidDvPacket(const CBuffer &Buffer, CYSFFICH *Fich) } -bool CYsfProtocol::IsValidDvHeaderPacket(const CIp &Ip, const CYSFFICH &Fich, const CBuffer &Buffer, CDvHeaderPacket **header, CDvFramePacket **frames) +bool CYsfProtocol::IsValidDvHeaderPacket(const CIp &Ip, const CYSFFICH &Fich, const CBuffer &Buffer, std::unique_ptr &header, std::array, 5> &frames) { - bool valid = false; - *header = nullptr; - frames[0] = nullptr; - frames[1] = nullptr; - // DV header ? if ( Fich.getFI() == YSF_FI_HEADER ) { @@ -471,49 +437,26 @@ bool CYsfProtocol::IsValidDvHeaderPacket(const CIp &Ip, const CYSFFICH &Fich, co rpt2.SetModule(' '); // and packet - *header = new CDvHeaderPacket(csMY, CCallsign("CQCQCQ"), rpt1, rpt2, uiStreamId, Fich.getFN()); + header = std::unique_ptr(new CDvHeaderPacket(csMY, CCallsign("CQCQCQ"), rpt1, rpt2, uiStreamId, Fich.getFN())); } // and 2 DV Frames { uint8 uiAmbe[AMBE_SIZE]; ::memset(uiAmbe, 0x00, sizeof(uiAmbe)); - frames[0] = new CDvFramePacket(uiAmbe, uiStreamId, Fich.getFN(), 0, 0); - frames[1] = new CDvFramePacket(uiAmbe, uiStreamId, Fich.getFN(), 1, 0); + frames[0] = std::unique_ptr(new CDvFramePacket(uiAmbe, uiStreamId, Fich.getFN(), 0, 0)); + frames[1] = std::unique_ptr(new CDvFramePacket(uiAmbe, uiStreamId, Fich.getFN(), 1, 0)); } // check validity of packets - if ( ((*header) == nullptr) || !(*header)->IsValid() || - (frames[0] == nullptr) || !(frames[0]->IsValid()) || - (frames[1] == nullptr) || !(frames[1]->IsValid()) ) - - { - delete *header; - *header = nullptr; - delete frames[0]; - delete frames[1]; - frames[0] = nullptr; - frames[1] = nullptr; - } - else - { - valid = true; - } + if ( header && frames[0] && frames[1] && header->IsValid() && frames[0]->IsValid() && frames[1]->IsValid() ) + return true; } - - // done - return valid; + return false; } -bool CYsfProtocol::IsValidDvFramePacket(const CIp &Ip, const CYSFFICH &Fich, const CBuffer &Buffer, CDvFramePacket **frames) +bool CYsfProtocol::IsValidDvFramePacket(const CIp &Ip, const CYSFFICH &Fich, const CBuffer &Buffer, std::array, 5> &frames) { - bool valid = false; - frames[0] = nullptr; - frames[1] = nullptr; - frames[2] = nullptr; - frames[3] = nullptr; - frames[4] = nullptr; - // is it DV frame ? if ( Fich.getFI() == YSF_FI_COMMUNICATIONS ) { @@ -531,46 +474,21 @@ bool CYsfProtocol::IsValidDvFramePacket(const CIp &Ip, const CYSFFICH &Fich, con // get DV frames uint8 fid = Buffer.data()[34]; - frames[0] = new CDvFramePacket(ambe0, uiStreamId, Fich.getFN(), 0, fid); - frames[1] = new CDvFramePacket(ambe1, uiStreamId, Fich.getFN(), 1, fid); - frames[2] = new CDvFramePacket(ambe2, uiStreamId, Fich.getFN(), 2, fid); - frames[3] = new CDvFramePacket(ambe3, uiStreamId, Fich.getFN(), 3, fid); - frames[4] = new CDvFramePacket(ambe4, uiStreamId, Fich.getFN(), 4, fid); + frames[0] = std::unique_ptr(new CDvFramePacket(ambe0, uiStreamId, Fich.getFN(), 0, fid)); + frames[1] = std::unique_ptr(new CDvFramePacket(ambe1, uiStreamId, Fich.getFN(), 1, fid)); + frames[2] = std::unique_ptr(new CDvFramePacket(ambe2, uiStreamId, Fich.getFN(), 2, fid)); + frames[3] = std::unique_ptr(new CDvFramePacket(ambe3, uiStreamId, Fich.getFN(), 3, fid)); + frames[4] = std::unique_ptr(new CDvFramePacket(ambe4, uiStreamId, Fich.getFN(), 4, fid)); // check validity of packets - if ( (frames[0] == nullptr) || !(frames[0]->IsValid()) || - (frames[1] == nullptr) || !(frames[1]->IsValid()) || - (frames[2] == nullptr) || !(frames[2]->IsValid()) || - (frames[3] == nullptr) || !(frames[3]->IsValid()) || - (frames[4] == nullptr) || !(frames[4]->IsValid()) ) - { - delete frames[0]; - delete frames[1]; - delete frames[2]; - delete frames[3]; - delete frames[4]; - frames[0] = nullptr; - frames[1] = nullptr; - frames[2] = nullptr; - frames[3] = nullptr; - frames[4] = nullptr; - } - else - { - valid = true; - } + if ( frames[0] && frames[0]->IsValid() && frames[1] && frames[1]->IsValid() && frames[2] && frames[2]->IsValid() && frames[3] && frames[3]->IsValid() && frames[4] && frames[4]->IsValid() ) + return true; } - - // done - return valid; + return false; } -bool CYsfProtocol::IsValidDvLastFramePacket(const CIp &Ip, const CYSFFICH &Fich, const CBuffer &Buffer, CDvFramePacket **frames) +bool CYsfProtocol::IsValidDvLastFramePacket(const CIp &Ip, const CYSFFICH &Fich, const CBuffer &Buffer, std::unique_ptr &oneframe, std::unique_ptr &lastframe) { - bool valid = false; - frames[0] = nullptr; - frames[1] = nullptr; - // DV header ? if ( Fich.getFI() == YSF_FI_TERMINATOR ) { @@ -581,28 +499,15 @@ bool CYsfProtocol::IsValidDvLastFramePacket(const CIp &Ip, const CYSFFICH &Fich, { uint8 uiAmbe[AMBE_SIZE]; ::memset(uiAmbe, 0x00, sizeof(uiAmbe)); - frames[0] = new CDvFramePacket(uiAmbe, uiStreamId, Fich.getFN(), 0, 0); - frames[1] = new CDvLastFramePacket(uiAmbe, uiStreamId, Fich.getFN(), 1, 0); + oneframe = std::unique_ptr(new CDvFramePacket(uiAmbe, uiStreamId, Fich.getFN(), 0, 0)); + lastframe = std::unique_ptr(new CDvLastFramePacket(uiAmbe, uiStreamId, Fich.getFN(), 1, 0)); } // check validity of packets - if ( (frames[0] == nullptr) || !(frames[0]->IsValid()) || - (frames[1] == nullptr) || !(frames[1]->IsValid()) ) - - { - delete frames[0]; - delete frames[1]; - frames[0] = nullptr; - frames[1] = nullptr; - } - else - { - valid = true; - } + if ( (oneframe && oneframe->IsValid()) && lastframe && lastframe->IsValid() ) + return true; } - - // done - return valid; + return false; } //////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/cysfprotocol.h b/src/cysfprotocol.h index 459c060..52c7f39 100644 --- a/src/cysfprotocol.h +++ b/src/cysfprotocol.h @@ -73,9 +73,6 @@ public: // constructor CYsfProtocol(); - // destructor - ~CYsfProtocol() {} - // initialization bool Initalize(const char *type, const uint16 port, const bool has_ipv4, const bool has_ipv6); void Close(void); @@ -91,15 +88,15 @@ protected: void HandleKeepalives(void); // stream helpers - bool OnDvHeaderPacketIn(CDvHeaderPacket *, const CIp &); + void OnDvHeaderPacketIn(std::unique_ptr &, const CIp &); // DV packet decoding helpers bool IsValidConnectPacket(const CBuffer &, CCallsign *); //bool IsValidDisconnectPacket(const CBuffer &, CCallsign *); bool IsValidDvPacket(const CBuffer &, CYSFFICH *); - bool IsValidDvHeaderPacket(const CIp &, const CYSFFICH &, const CBuffer &, CDvHeaderPacket **, CDvFramePacket **); - bool IsValidDvFramePacket(const CIp &, const CYSFFICH &, const CBuffer &, CDvFramePacket **); - bool IsValidDvLastFramePacket(const CIp &, const CYSFFICH &, const CBuffer &, CDvFramePacket **); + bool IsValidDvHeaderPacket(const CIp &, const CYSFFICH &, const CBuffer &, std::unique_ptr &, std::array, 5> &); + bool IsValidDvFramePacket(const CIp &, const CYSFFICH &, const CBuffer &, std::array, 5> &); + bool IsValidDvLastFramePacket(const CIp &, const CYSFFICH &, const CBuffer &, std::unique_ptr &, std::unique_ptr &); // DV packet encoding helpers void EncodeConnectAckPacket(CBuffer *) const;