xlx 1.3.4

* improved DCS compatibility
* added full REFxxx DPlus support
* added more flags & countries in dashboard

dashboard/pgs/country.csv

@@ -55,7 +55,7 @@ Costa Rica;CR;TI-TE
 Cote d'Ivoire;CI;TU
 Croatia;HR;9A
 Cuba;CU;CO-CM
-Curaçao;CW;PJ2
+Curacao;CW;PJ2
 Cyprus;CY;5B-C4-P3
 Czech Republic;CZ;OK-OL
 Denmark;DK;OU-OV-OW-OZ
@@ -73,10 +73,10 @@ Falkland Islands (Malvinas);FK;VP8
 Faroe Islands;FO;OY
 Fiji;FJ;3D2
 Finland;FI;OF-OG-OH-OI
-France;FR;F0-F1-F2-F3-F4-F5-F6-F7-F8-F9
+France;FR;F0-F1-F2-F3-F4-F5-F6-F7-F8-F9-TK
 French Guiana;GF;FY
 French Polynesia;PF;FO-TX
-French Southern Territories;TF;TK
+French Southern Territories;TF;
 Gabon;GA;TR
 Gambia;GM;C5
 Georgia;GE;4L
@@ -104,7 +104,7 @@ India;IN;VU
 Indonesia;ID;YB-YC-YD-YE-YF-YG-YH
 Iran, Islamic Republic of;IR;EP-EQ
 Iraq;IQ;YI
-Ireland;IE;EI-EJ-MI
+Ireland;IE;EI-EJ-MI-GI
 Isle of Man;IM;GD-GT
 Israel;IL;4X-4Z
 Italy;IT;I0-I1-I2-I3-I4-I5-I6-I7-I8-I9-IK-TR-IT-IU-IW-IZ
@@ -175,7 +175,7 @@ Peru;PE;OA-OB-OC
 Philippines;PH;DU-DV-DW-DX-DY-DZ-4D-4E-4F-4G-4H-4I
 Pitcairn;PN;VP6
 Poland;PL;SN-SO-SP-SQ-SR
-Portugal;PT;CT
+Portugal;PT;CT-CU3
 Puerto Rico;PR;KP3-KP4
 Qatar;QA;A7
 Reunion;RE;FR-TO
@@ -234,7 +234,7 @@ Uganda;UG;5X
 Ukraine;UA;UR-US-UT-UU-UV-UW-UX-UY-UZ
 United Arab Emirates;AE;A6
 United Kingdom;GB;2E-M0-M1-M2-M3-M4-M5-M6-M7-M8-M9-MB-MM-G0-G1-G2-G3-G4-G5-G6-G7-G8-G9-GX
-United States;US;K0-K1-K2-K3-K4-K5-K6-K7-K8-K9-KA-KB-KC-KD-KE-KF-KI-KJ-KM-W0-W1-W2-W3-W4-W5-W6-W7-W8-W9-WA-WB-WX-N0-N1-N2-N3-N4-N5-N6-N7-N8-N9-NS-NO-AA-AB-AC-AD-AE-AF-AG-AH-AI-AJ-AK
+United States;US;K0-K1-K2-K3-K4-K5-K6-K7-K8-K9-KA-KB-KC-KD-KE-KF-KG-KI-KJ-KK-KM-KN-KO-KQ-KR-KS-KT-KU-KV-KW-KX-KY-KZ-W0-W1-W2-W3-W4-W5-W6-W7-W8-W9-WA-WB-WD-WX-N0-N1-N2-N3-N4-N5-N6-N7-N8-N9-NS-NO-AA-AB-AC-AD-AE-AF-AG-AH-AI-AJ-AK
 United States Minor Outlying Islands;UM;
 Uruguay;UY;CV-CW-CX
 Uzbekistan;UZ;UJ-UK-UL-UM

src/cclient.h

@@ -68,6 +68,8 @@ public:
     virtual const char *GetProtocolName(void) const     { return "none"; }
     virtual bool IsNode(void) const                     { return false; }
     virtual bool IsPeer(void) const                     { return false; }
+    virtual bool IsDextraDongle(void) const             { return false; }
+    virtual void SetDextraDongle(void)                  { }
     
     // status
     virtual void Alive(void);

src/cdcsprotocol.cpp

@@ -127,7 +127,7 @@ void CDcsProtocol::Task(void)
             if ( g_GateKeeper.MayLink(Callsign, Ip, PROTOCOL_DCS) )
             {
                 // acknowledge the request
-                EncodeConnectAckPacket(Callsign, &Buffer);
+                EncodeConnectAckPacket(Callsign, ToLinkModule, &Buffer);
                 m_Socket.Send(Buffer, Ip);
                 
                 // create the client
@@ -140,7 +140,7 @@ void CDcsProtocol::Task(void)
             else
             {
                 // deny the request
-                EncodeConnectNackPacket(Callsign, &Buffer);
+                EncodeConnectNackPacket(Callsign, ToLinkModule, &Buffer);
                 m_Socket.Send(Buffer, Ip);
             }
          
@@ -172,9 +172,15 @@ void CDcsProtocol::Task(void)
             }
             g_Reflector.ReleaseClients();
         }
+        else if ( IsIgnorePacket(Buffer) )
+        {
+            // valid but ignore packet
+            //std::cout << "DCS ignored packet from " << Ip << std::endl;
+        }
         else
         {
-            std::cout << "DCS packet (" << Buffer.size() << ")" << std::endl;
+            // invalid packet
+            std::cout << "DCS packet (" << Buffer.size() << ") from " << Ip << std::endl;
         }
     }
     
@@ -390,7 +396,7 @@ bool CDcsProtocol::IsValidDisconnectPacket(const CBuffer &Buffer, CCallsign *cal
 bool CDcsProtocol::IsValidKeepAlivePacket(const CBuffer &Buffer, CCallsign *callsign)
 {
     bool valid = false;
-    if (Buffer.size() == 17)
+    if ( (Buffer.size() == 17) || (Buffer.size() == 15) || (Buffer.size() == 22) )
     {
         callsign->SetCallsign(Buffer.data(), 8);
         valid = callsign->IsValid();
@@ -443,6 +449,18 @@ bool CDcsProtocol::IsValidDvPacket(const CBuffer &Buffer, CDvHeaderPacket **head
     return valid;
 }
 
+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;
+}
+
 
 ////////////////////////////////////////////////////////////////////////////////////////
 // packet encoding helpers
@@ -454,35 +472,40 @@ void CDcsProtocol::EncodeKeepAlivePacket(CBuffer *Buffer)
 
 void CDcsProtocol::EncodeKeepAlivePacket(CBuffer *Buffer, CClient *Client)
 {
+    uint8 tag[] = { 0x0A,0x00,0x20,0x20 };
+    
     Buffer->Set((uint8 *)(const char *)GetReflectorCallsign(), CALLSIGN_LEN-1);
     Buffer->Append((uint8)Client->GetReflectorModule());
-    Buffer->Append((uint8)0);
+    Buffer->Append((uint8)' ');
-    Buffer->Append((uint8 *)(const char *)Client->GetCallsign(), CALLSIGN_LEN);
+    Buffer->Append((uint8 *)(const char *)Client->GetCallsign(), CALLSIGN_LEN-1);
+    Buffer->Append((uint8)Client->GetModule());
     Buffer->Append((uint8)Client->GetModule());
-    Buffer->Append((uint8)0, 4);
+    Buffer->Append(tag, sizeof(tag));
 }
 
-void CDcsProtocol::EncodeConnectAckPacket(const CCallsign &Callsign, CBuffer *Buffer)
+void CDcsProtocol::EncodeConnectAckPacket(const CCallsign &Callsign, char ReflectorModule, CBuffer *Buffer)
 {
-    uint8 tag[] = { 'E','A','C','K',0x00 };
+    uint8 tag[] = { 'A','C','K',0x00 };
     uint8 cs[CALLSIGN_LEN];
     
     Callsign.GetCallsign(cs);
     Buffer->Set(cs, CALLSIGN_LEN-1);
     Buffer->Append((uint8)' ');
     Buffer->Append((uint8)Callsign.GetModule());
+    Buffer->Append((uint8)ReflectorModule);
     Buffer->Append(tag, sizeof(tag));
 }
 
-void CDcsProtocol::EncodeConnectNackPacket(const CCallsign &Callsign, CBuffer *Buffer)
+void CDcsProtocol::EncodeConnectNackPacket(const CCallsign &Callsign, char ReflectorModule, CBuffer *Buffer)
 {
-    uint8 tag[] = { 'E','N','A','K',0x00 };
+    uint8 tag[] = { 'N','A','K',0x00 };
     uint8 cs[CALLSIGN_LEN];
     
     Callsign.GetCallsign(cs);
     Buffer->Set(cs, CALLSIGN_LEN-1);
     Buffer->Append((uint8)' ');
     Buffer->Append((uint8)Callsign.GetModule());
+    Buffer->Append((uint8)ReflectorModule);
     Buffer->Append(tag, sizeof(tag));
 }
 

src/cdcsprotocol.h

@@ -67,12 +67,13 @@ protected:
     bool IsValidDisconnectPacket(const CBuffer &, CCallsign *);
     bool IsValidKeepAlivePacket(const CBuffer &, CCallsign *);
     bool IsValidDvPacket(const CBuffer &, CDvHeaderPacket **, CDvFramePacket **);
+    bool IsIgnorePacket(const CBuffer &);
     
     // packet encoding helpers
     void EncodeKeepAlivePacket(CBuffer *);
     void EncodeKeepAlivePacket(CBuffer *, CClient *);
-    void EncodeConnectAckPacket(const CCallsign &, CBuffer *);
+    void EncodeConnectAckPacket(const CCallsign &, char, CBuffer *);
-    void EncodeConnectNackPacket(const CCallsign &, CBuffer *);
+    void EncodeConnectNackPacket(const CCallsign &, char, CBuffer *);
     void EncodeDisconnectPacket(CBuffer *, CClient *);
     void EncodeDvPacket(const CDvHeaderPacket &, const CDvFramePacket &, uint32, CBuffer *) const;
     void EncodeDvLastPacket(const CDvHeaderPacket &, const CDvFramePacket &, uint32, CBuffer *) const;

src/cdplusclient.cpp

@@ -31,16 +31,19 @@
 
 CDplusClient::CDplusClient()
 {
+    m_bDextraDongle = false;
 }
 
 CDplusClient::CDplusClient(const CCallsign &callsign, const CIp &ip, char reflectorModule)
     : CClient(callsign, ip, reflectorModule)
 {
+    m_bDextraDongle = false;
 }
 
 CDplusClient::CDplusClient(const CDplusClient &client)
     : CClient(client)
 {
+    m_bDextraDongle = client.m_bDextraDongle;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////

src/cdplusclient.h

@@ -49,10 +49,16 @@ public:
     int GetProtocol(void) const                 { return PROTOCOL_DPLUS; }
     const char *GetProtocolName(void) const     { return "Dplus"; }
     bool IsNode(void) const                     { return true; }
+    bool IsDextraDongle(void) const             { return m_bDextraDongle; }
+    void SetDextraDongle(void)                  { m_bDextraDongle = true; }
     
     // status
     bool IsAlive(void) const;
     void SetMasterOfModule(char);
+    
+protected:
+    // data
+    bool m_bDextraDongle;
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////

src/cdplusprotocol.cpp

@@ -41,8 +41,8 @@ bool CDplusProtocol::Init(void)
     ok = CProtocol::Init();
     
     // update the reflector callsign
-    //m_ReflectorCallsign.PatchCallsign(0, (const uint8 *)"REF", 3);
+    m_ReflectorCallsign.PatchCallsign(0, (const uint8 *)"REF", 3);
-    m_ReflectorCallsign.PatchCallsign(0, (const uint8 *)"XRF", 3);
+    //m_ReflectorCallsign.PatchCallsign(0, (const uint8 *)"XRF", 3);
     
     // create our socket
     ok &= m_Socket.Open(DPLUS_PORT);
@@ -202,10 +202,15 @@ bool CDplusProtocol::OnDvHeaderPacketIn(CDvHeaderPacket *Header, const CIp &Ip)
         // no stream open yet, open a new one
         CCallsign via(Header->GetRpt1Callsign());
         
-       // find this client
+        // find this client
         CClient *client = g_Reflector.GetClients()->FindClient(Ip, PROTOCOL_DPLUS);
         if ( client != NULL )
         {
+            // now we knwo if it's a dextra dongle or a genuine dplus node
+            if ( Header->GetRpt2Callsign().HasSameCallsignWithWidlcard(CCallsign("XRF*"))  )
+            {
+                client->SetDextraDongle();
+            }
             // now we know its module, let's update it
             if ( !client->HasModule() )
             {
@@ -268,9 +273,35 @@ void CDplusProtocol::HandleQueue(void)
                 // is this client busy ?
                 if ( !client->IsAMaster() )
                 {
-                    // no, send the packet
+                    // check if client is a dextra dongle
-                    m_Socket.Send(buffer, client->GetIp());
+                    // then replace RPT2 with XRF instead of REF
-                    
+                    // if the client type is not yet known, send bothheaders
+                    if ( packet->IsDvHeader() && (client->IsDextraDongle() || !client->HasModule()) )
+                    {
+                        // clone the packet and patch it
+                        CDvHeaderPacket packet2(*((CDvHeaderPacket *)packet));
+                        CCallsign rpt2 = packet2.GetRpt2Callsign();
+                        rpt2.PatchCallsign(0, (const uint8 *)"XRF", 3);
+                        packet2.SetRpt2Callsign(rpt2);
+                        // encode it
+                        CBuffer buffer2;
+                        if ( EncodeDvPacket(packet2, &buffer2) )
+                        {
+                            // and send it
+                            m_Socket.Send(buffer2, client->GetIp());
+                        }
+                        // client type known ?
+                        if ( !client->HasModule() )
+                        {
+                            // no, send also the genuine packet
+                            m_Socket.Send(buffer, client->GetIp());
+                        }
+                    }
+                    else
+                    {
+                        // no, send the original packet
+                        m_Socket.Send(buffer, client->GetIp());
+                    }
                 }
             }
             g_Reflector.ReleaseClients();

src/main.h

@@ -48,7 +48,7 @@
 
 #define VERSION_MAJOR               1
 #define VERSION_MINOR               3
-#define VERSION_REVISION            1
+#define VERSION_REVISION            4
 
 // global ------------------------------------------------------