Add an optional third DMR Network.

Conf.cpp

@@ -27,14 +27,15 @@
 const int BUFFER_SIZE = 500;
 
 enum SECTION {
-  SECTION_NONE,
+	SECTION_NONE,
-  SECTION_GENERAL,
+	SECTION_GENERAL,
-  SECTION_LOG,
+	SECTION_LOG,
-  SECTION_VOICE,
+	SECTION_VOICE,
-  SECTION_INFO,
+	SECTION_INFO,
-  SECTION_DMR_NETWORK_1,
+	SECTION_DMR_NETWORK_1,
-  SECTION_DMR_NETWORK_2,
+	SECTION_DMR_NETWORK_2,
-  SECTION_XLX_NETWORK
+	SECTION_DMR_NETWORK_3,
+	SECTION_XLX_NETWORK
 };
 
 CConf::CConf(const std::string& file) :
@@ -97,6 +98,22 @@ m_dmrNetwork2TypeRewrites(),
 m_dmrNetwork2SrcRewrites(),
 m_dmrNetwork2PassAllPC(),
 m_dmrNetwork2PassAllTG(),
+m_dmrNetwork3Enabled(false),
+m_dmrNetwork3Name(),
+m_dmrNetwork3Id(0U),
+m_dmrNetwork3Address(),
+m_dmrNetwork3Port(0U),
+m_dmrNetwork3Local(0U),
+m_dmrNetwork3Password(),
+m_dmrNetwork3Options(),
+m_dmrNetwork3Location(true),
+m_dmrNetwork3Debug(false),
+m_dmrNetwork3TGRewrites(),
+m_dmrNetwork3PCRewrites(),
+m_dmrNetwork3TypeRewrites(),
+m_dmrNetwork3SrcRewrites(),
+m_dmrNetwork3PassAllPC(),
+m_dmrNetwork3PassAllTG(),
 m_xlxNetworkEnabled(false),
 m_xlxNetworkId(0U),
 m_xlxNetworkFile(),
@@ -147,6 +164,8 @@ bool CConf::read()
 			section = SECTION_DMR_NETWORK_1;
 		else if (::strncmp(buffer, "[DMR Network 2]", 15U) == 0)
 			section = SECTION_DMR_NETWORK_2;
+		else if (::strncmp(buffer, "[DMR Network 3]", 15U) == 0)
+			section = SECTION_DMR_NETWORK_3;
 		else
 			section = SECTION_NONE;
 
@@ -418,6 +437,92 @@ bool CConf::read()
 				unsigned int slotNo = (unsigned int)::atoi(value);
 				m_dmrNetwork2PassAllTG.push_back(slotNo);
 			}
+		} else if (section == SECTION_DMR_NETWORK_3) {
+			if (::strcmp(key, "Enabled") == 0)
+				m_dmrNetwork3Enabled = ::atoi(value) == 1;
+			else if (::strcmp(key, "Name") == 0)
+				m_dmrNetwork3Name = value;
+			else if (::strcmp(key, "Id") == 0)
+				m_dmrNetwork3Id = (unsigned int)::atoi(value);
+			else if (::strcmp(key, "Address") == 0)
+				m_dmrNetwork3Address = value;
+			else if (::strcmp(key, "Port") == 0)
+				m_dmrNetwork3Port = (unsigned int)::atoi(value);
+			else if (::strcmp(key, "Local") == 0)
+				m_dmrNetwork3Local = (unsigned int)::atoi(value);
+			else if (::strcmp(key, "Password") == 0)
+				m_dmrNetwork3Password = value;
+			else if (::strcmp(key, "Options") == 0)
+				m_dmrNetwork3Options = value;
+			else if (::strcmp(key, "Location") == 0)
+				m_dmrNetwork3Location = ::atoi(value) == 1;
+			else if (::strcmp(key, "Debug") == 0)
+				m_dmrNetwork3Debug = ::atoi(value) == 1;
+			else if (::strcmp(key, "TGRewrite") == 0) {
+				char* p1 = ::strtok(value, ", ");
+				char* p2 = ::strtok(NULL, ", ");
+				char* p3 = ::strtok(NULL, ", ");
+				char* p4 = ::strtok(NULL, ", ");
+				char* p5 = ::strtok(NULL, " \r\n");
+				if (p1 != NULL && p2 != NULL && p3 != NULL && p4 != NULL && p5 != NULL) {
+					CTGRewriteStruct rewrite;
+					rewrite.m_fromSlot = ::atoi(p1);
+					rewrite.m_fromTG   = ::atoi(p2);
+					rewrite.m_toSlot   = ::atoi(p3);
+					rewrite.m_toTG     = ::atoi(p4);
+					rewrite.m_range    = ::atoi(p5);
+					m_dmrNetwork3TGRewrites.push_back(rewrite);
+				}
+			} else if (::strcmp(key, "PCRewrite") == 0) {
+				char* p1 = ::strtok(value, ", ");
+				char* p2 = ::strtok(NULL, ", ");
+				char* p3 = ::strtok(NULL, ", ");
+				char* p4 = ::strtok(NULL, ", ");
+				char* p5 = ::strtok(NULL, " \r\n");
+				if (p1 != NULL && p2 != NULL && p3 != NULL && p4 != NULL && p5 != NULL) {
+					CPCRewriteStruct rewrite;
+					rewrite.m_fromSlot = ::atoi(p1);
+					rewrite.m_fromId   = ::atoi(p2);
+					rewrite.m_toSlot   = ::atoi(p3);
+					rewrite.m_toId     = ::atoi(p4);
+					rewrite.m_range    = ::atoi(p5);
+					m_dmrNetwork3PCRewrites.push_back(rewrite);
+				}
+			} else if (::strcmp(key, "TypeRewrite") == 0) {
+				char* p1 = ::strtok(value, ", ");
+				char* p2 = ::strtok(NULL, ", ");
+				char* p3 = ::strtok(NULL, ", ");
+				char* p4 = ::strtok(NULL, " \r\n");
+				if (p1 != NULL && p2 != NULL && p3 != NULL && p4 != NULL) {
+					CTypeRewriteStruct rewrite;
+					rewrite.m_fromSlot = ::atoi(p1);
+					rewrite.m_fromTG   = ::atoi(p2);
+					rewrite.m_toSlot   = ::atoi(p3);
+					rewrite.m_toId     = ::atoi(p4);
+					m_dmrNetwork3TypeRewrites.push_back(rewrite);
+				}
+			} else if (::strcmp(key, "SrcRewrite") == 0) {
+				char* p1 = ::strtok(value, ", ");
+				char* p2 = ::strtok(NULL, ", ");
+				char* p3 = ::strtok(NULL, ", ");
+				char* p4 = ::strtok(NULL, ", ");
+				char* p5 = ::strtok(NULL, " \r\n");
+				if (p1 != NULL && p2 != NULL && p3 != NULL && p4 != NULL && p5 != NULL) {
+					CSrcRewriteStruct rewrite;
+					rewrite.m_fromSlot = ::atoi(p1);
+					rewrite.m_fromId   = ::atoi(p2);
+					rewrite.m_toSlot   = ::atoi(p3);
+					rewrite.m_toTG     = ::atoi(p4);
+					rewrite.m_range    = ::atoi(p5);
+					m_dmrNetwork3SrcRewrites.push_back(rewrite);
+				}
+			} else if (::strcmp(key, "PassAllPC") == 0) {
+				unsigned int slotNo = (unsigned int)::atoi(value);
+				m_dmrNetwork3PassAllPC.push_back(slotNo);
+			} else if (::strcmp(key, "PassAllTG") == 0) {
+				unsigned int slotNo = (unsigned int)::atoi(value);
+				m_dmrNetwork3PassAllTG.push_back(slotNo);
+			}
 		}
 	}
 
@@ -786,3 +891,86 @@ std::vector<unsigned int> CConf::getDMRNetwork2PassAllTG() const
 {
 	return m_dmrNetwork2PassAllTG;
 }
+
+bool CConf::getDMRNetwork3Enabled() const
+{
+	return m_dmrNetwork3Enabled;
+}
+
+std::string CConf::getDMRNetwork3Name() const
+{
+	if (m_dmrNetwork3Name.empty())
+		return "DMR-3";
+	else
+		return m_dmrNetwork3Name;
+}
+
+unsigned int CConf::getDMRNetwork3Id() const
+{
+	return m_dmrNetwork3Id;
+}
+
+std::string CConf::getDMRNetwork3Address() const
+{
+	return m_dmrNetwork3Address;
+}
+
+unsigned int CConf::getDMRNetwork3Port() const
+{
+	return m_dmrNetwork3Port;
+}
+
+unsigned int CConf::getDMRNetwork3Local() const
+{
+	return m_dmrNetwork3Local;
+}
+
+std::string CConf::getDMRNetwork3Password() const
+{
+	return m_dmrNetwork3Password;
+}
+
+std::string CConf::getDMRNetwork3Options() const
+{
+	return m_dmrNetwork3Options;
+}
+
+bool CConf::getDMRNetwork3Location() const
+{
+	return m_dmrNetwork3Location;
+}
+
+bool CConf::getDMRNetwork3Debug() const
+{
+	return m_dmrNetwork3Debug;
+}
+
+std::vector<CTGRewriteStruct> CConf::getDMRNetwork3TGRewrites() const
+{
+	return m_dmrNetwork3TGRewrites;
+}
+
+std::vector<CPCRewriteStruct> CConf::getDMRNetwork3PCRewrites() const
+{
+	return m_dmrNetwork3PCRewrites;
+}
+
+std::vector<CTypeRewriteStruct> CConf::getDMRNetwork3TypeRewrites() const
+{
+	return m_dmrNetwork3TypeRewrites;
+}
+
+std::vector<CSrcRewriteStruct> CConf::getDMRNetwork3SrcRewrites() const
+{
+	return m_dmrNetwork3SrcRewrites;
+}
+
+std::vector<unsigned int> CConf::getDMRNetwork3PassAllPC() const
+{
+	return m_dmrNetwork3PassAllPC;
+}
+
+std::vector<unsigned int> CConf::getDMRNetwork3PassAllTG() const
+{
+	return m_dmrNetwork3PassAllTG;
+}

Conf.h

@@ -131,6 +131,24 @@ public:
 	std::vector<unsigned int>       getDMRNetwork2PassAllPC() const;
 	std::vector<unsigned int>       getDMRNetwork2PassAllTG() const;
 
+	// The DMR Network 3 section
+	bool         getDMRNetwork3Enabled() const;
+	std::string  getDMRNetwork3Name() const;
+	unsigned int getDMRNetwork3Id() const;
+	std::string  getDMRNetwork3Address() const;
+	unsigned int getDMRNetwork3Port() const;
+	unsigned int getDMRNetwork3Local() const;
+	std::string  getDMRNetwork3Password() const;
+	std::string  getDMRNetwork3Options() const;
+	bool         getDMRNetwork3Location() const;
+	bool         getDMRNetwork3Debug() const;
+	std::vector<CTGRewriteStruct>   getDMRNetwork3TGRewrites() const;
+	std::vector<CPCRewriteStruct>   getDMRNetwork3PCRewrites() const;
+	std::vector<CTypeRewriteStruct> getDMRNetwork3TypeRewrites() const;
+	std::vector<CSrcRewriteStruct>  getDMRNetwork3SrcRewrites() const;
+	std::vector<unsigned int>       getDMRNetwork3PassAllPC() const;
+	std::vector<unsigned int>       getDMRNetwork3PassAllTG() const;
+
 	// The XLX Network section
 	bool         getXLXNetworkEnabled() const;
 	unsigned int getXLXNetworkId() const;
@@ -212,6 +230,23 @@ private:
 	std::vector<unsigned int>       m_dmrNetwork2PassAllPC;
 	std::vector<unsigned int>       m_dmrNetwork2PassAllTG;
 
+	bool         m_dmrNetwork3Enabled;
+	std::string  m_dmrNetwork3Name;
+	unsigned int m_dmrNetwork3Id;
+	std::string  m_dmrNetwork3Address;
+	unsigned int m_dmrNetwork3Port;
+	unsigned int m_dmrNetwork3Local;
+	std::string  m_dmrNetwork3Password;
+	std::string  m_dmrNetwork3Options;
+	bool         m_dmrNetwork3Location;
+	bool         m_dmrNetwork3Debug;
+	std::vector<CTGRewriteStruct>   m_dmrNetwork3TGRewrites;
+	std::vector<CPCRewriteStruct>   m_dmrNetwork3PCRewrites;
+	std::vector<CTypeRewriteStruct> m_dmrNetwork3TypeRewrites;
+	std::vector<CSrcRewriteStruct>  m_dmrNetwork3SrcRewrites;
+	std::vector<unsigned int>       m_dmrNetwork3PassAllPC;
+	std::vector<unsigned int>       m_dmrNetwork3PassAllTG;
+
 	bool         m_xlxNetworkEnabled;
 	unsigned int m_xlxNetworkId;
 	std::string  m_xlxNetworkFile;

DMRGateway.cpp

@@ -70,6 +70,7 @@ enum DMRGW_STATUS {
 	DMRGWS_NONE,
 	DMRGWS_DMRNETWORK1,
 	DMRGWS_DMRNETWORK2,
+	DMRGWS_DMRNETWORK3,
 	DMRGWS_XLXREFLECTOR
 };
 
@@ -137,6 +138,8 @@ m_dmrNetwork1(NULL),
 m_dmr1Name(),
 m_dmrNetwork2(NULL),
 m_dmr2Name(),
+m_dmrNetwork3(NULL),
+m_dmr3Name(),
 m_xlxReflectors(NULL),
 m_xlxNetwork(NULL),
 m_xlxId(0U),
@@ -159,8 +162,11 @@ m_dmr1NetRewrites(),
 m_dmr1RFRewrites(),
 m_dmr2NetRewrites(),
 m_dmr2RFRewrites(),
+m_dmr3NetRewrites(),
+m_dmr3RFRewrites(),
 m_dmr1Passalls(),
-m_dmr2Passalls()
+m_dmr2Passalls(),
+m_dmr3Passalls()
 {
 	m_config = new unsigned char[400U];
 }
@@ -179,12 +185,21 @@ CDMRGateway::~CDMRGateway()
 	for (std::vector<CRewrite*>::iterator it = m_dmr2RFRewrites.begin(); it != m_dmr2RFRewrites.end(); ++it)
 			delete *it;
 
+	for (std::vector<CRewrite*>::iterator it = m_dmr3NetRewrites.begin(); it != m_dmr3NetRewrites.end(); ++it)
+		delete *it;
+
+	for (std::vector<CRewrite*>::iterator it = m_dmr3RFRewrites.begin(); it != m_dmr3RFRewrites.end(); ++it)
+		delete *it;
+
 	for (std::vector<CRewrite*>::iterator it = m_dmr1Passalls.begin(); it != m_dmr1Passalls.end(); ++it)
 		delete *it;
 
 	for (std::vector<CRewrite*>::iterator it = m_dmr2Passalls.begin(); it != m_dmr2Passalls.end(); ++it)
 		delete *it;
 
+	for (std::vector<CRewrite*>::iterator it = m_dmr3Passalls.begin(); it != m_dmr3Passalls.end(); ++it)
+		delete *it;
+
 	delete m_rptRewrite;
 	delete m_xlxRewrite;
 
@@ -311,6 +326,11 @@ int CDMRGateway::run()
 			return 1;
 	}
 
+	if (m_conf.getDMRNetwork3Enabled()) {
+		ret = createDMRNetwork3();
+		if (!ret)
+			return 1;
+	}
 
 	if (m_conf.getXLXNetworkEnabled()) {
 		ret = createXLXNetwork();
@@ -359,6 +379,10 @@ int CDMRGateway::run()
 	unsigned int dmr2DstId[3U];
 	dmr2SrcId[1U] = dmr2SrcId[2U] = dmr2DstId[1U] = dmr2DstId[2U] = 0U;
 
+	unsigned int dmr3SrcId[3U];
+	unsigned int dmr3DstId[3U];
+	dmr3SrcId[1U] = dmr3SrcId[2U] = dmr3DstId[1U] = dmr3DstId[2U] = 0U;
+
 	CStopWatch stopWatch;
 	stopWatch.start();
 
@@ -561,6 +585,28 @@ int CDMRGateway::run()
 							}
 						}
 					}
+
+					if (!rewritten) {
+						if (m_dmrNetwork3 != NULL) {
+							// Rewrite the slot and/or TG or neither
+							for (std::vector<CRewrite*>::iterator it = m_dmr3RFRewrites.begin(); it != m_dmr3RFRewrites.end(); ++it) {
+								bool ret = (*it)->process(data, trace);
+								if (ret) {
+									rewritten = true;
+									break;
+								}
+							}
+
+							if (rewritten) {
+								if (status[slotNo] == DMRGWS_NONE || status[slotNo] == DMRGWS_DMRNETWORK3) {
+									m_dmrNetwork3->write(data);
+									status[slotNo] = DMRGWS_DMRNETWORK3;
+									timer[slotNo]->setTimeout(rfTimeout);
+									timer[slotNo]->start();
+								}
+							}
+						}
+					}
 				}
 
 				if (!rewritten) {
@@ -605,6 +651,27 @@ int CDMRGateway::run()
 					}
 				}
 
+				if (!rewritten) {
+					if (m_dmrNetwork3 != NULL) {
+						for (std::vector<CRewrite*>::iterator it = m_dmr3Passalls.begin(); it != m_dmr3Passalls.end(); ++it) {
+							bool ret = (*it)->process(data, trace);
+							if (ret) {
+								rewritten = true;
+								break;
+							}
+						}
+
+						if (rewritten) {
+							if (status[slotNo] == DMRGWS_NONE || status[slotNo] == DMRGWS_DMRNETWORK3) {
+								m_dmrNetwork3->write(data);
+								status[slotNo] = DMRGWS_DMRNETWORK3;
+								timer[slotNo]->setTimeout(rfTimeout);
+								timer[slotNo]->start();
+							}
+						}
+					}
+				}
+
 				if (!rewritten && trace)
 					LogDebug("Rule Trace,\tnot matched so rejected");
 			}
@@ -726,6 +793,54 @@ int CDMRGateway::run()
 				m_repeater->writeBeacon();
 		}
 
+		if (m_dmrNetwork3 != NULL) {
+			ret = m_dmrNetwork3->read(data);
+			if (ret) {
+				unsigned int slotNo = data.getSlotNo();
+				unsigned int srcId = data.getSrcId();
+				unsigned int dstId = data.getDstId();
+				FLCO flco = data.getFLCO();
+
+				bool trace = false;
+				if (ruleTrace && (srcId != dmr3SrcId[slotNo] || dstId != dmr3DstId[slotNo])) {
+					dmr3SrcId[slotNo] = srcId;
+					dmr3DstId[slotNo] = dstId;
+					trace = true;
+				}
+
+				if (trace)
+					LogDebug("Rule Trace, network 3 transmission: Slot=%u Src=%u Dst=%s%u", slotNo, srcId, flco == FLCO_GROUP ? "TG" : "", dstId);
+
+				// Rewrite the slot and/or TG or neither
+				bool rewritten = false;
+				for (std::vector<CRewrite*>::iterator it = m_dmr3NetRewrites.begin(); it != m_dmr3NetRewrites.end(); ++it) {
+					bool ret = (*it)->process(data, trace);
+					if (ret) {
+						rewritten = true;
+						break;
+					}
+				}
+
+				if (rewritten) {
+					// Check that the rewritten slot is free to use.
+					slotNo = data.getSlotNo();
+					if (status[slotNo] == DMRGWS_NONE || status[slotNo] == DMRGWS_DMRNETWORK3) {
+						m_repeater->write(data);
+						status[slotNo] = DMRGWS_DMRNETWORK3;
+						timer[slotNo]->setTimeout(netTimeout);
+						timer[slotNo]->start();
+					}
+				}
+
+				if (!rewritten && trace)
+					LogDebug("Rule Trace,\tnot matched so rejected");
+			}
+
+			ret = m_dmrNetwork3->wantsBeacon();
+			if (ret)
+				m_repeater->writeBeacon();
+		}
+
 		unsigned char buffer[50U];
 		unsigned int length;
 		ret = m_repeater->readPosition(buffer, length);
@@ -736,6 +851,8 @@ int CDMRGateway::run()
 				m_dmrNetwork1->writePosition(buffer, length);
 			if (m_dmrNetwork2 != NULL)
 				m_dmrNetwork2->writePosition(buffer, length);
+			if (m_dmrNetwork3 != NULL)
+				m_dmrNetwork3->writePosition(buffer, length);
 		}
 		ret = m_repeater->readTalkerAlias(buffer, length);
 		if (ret) {
@@ -745,6 +862,8 @@ int CDMRGateway::run()
 				m_dmrNetwork1->writeTalkerAlias(buffer, length);
 			if (m_dmrNetwork2 != NULL)
 				m_dmrNetwork2->writeTalkerAlias(buffer, length);
+			if (m_dmrNetwork3 != NULL)
+				m_dmrNetwork3->writeTalkerAlias(buffer, length);
 		}
 
 		if (voice != NULL) {
@@ -770,11 +889,14 @@ int CDMRGateway::run()
 		if (m_dmrNetwork2 != NULL)
 			m_dmrNetwork2->clock(ms);
 
+		if (m_dmrNetwork3 != NULL)
+			m_dmrNetwork3->clock(ms);
+
 		if (m_xlxNetwork != NULL)
 			m_xlxNetwork->clock(ms);
 
-        if (m_xlxReflectors != NULL)
+		if (m_xlxReflectors != NULL)
-            m_xlxReflectors->clock(ms);
+			m_xlxReflectors->clock(ms);
 
 		if (voice != NULL)
 			voice->clock(ms);
@@ -806,6 +928,11 @@ int CDMRGateway::run()
 		delete m_dmrNetwork2;
 	}
 
+	if (m_dmrNetwork3 != NULL) {
+		m_dmrNetwork3->close();
+		delete m_dmrNetwork3;
+	}
+
 	if (m_xlxNetwork != NULL) {
 		m_xlxNetwork->close();
 		delete m_xlxNetwork;
@@ -1099,6 +1226,133 @@ bool CDMRGateway::createDMRNetwork2()
 	return true;
 }
 
+bool CDMRGateway::createDMRNetwork3()
+{
+	std::string address  = m_conf.getDMRNetwork3Address();
+	unsigned int port    = m_conf.getDMRNetwork3Port();
+	unsigned int local   = m_conf.getDMRNetwork3Local();
+	unsigned int id      = m_conf.getDMRNetwork3Id();
+	std::string password = m_conf.getDMRNetwork3Password();
+	bool location        = m_conf.getDMRNetwork3Location();
+	bool debug           = m_conf.getDMRNetwork3Debug();
+	m_dmr3Name           = m_conf.getDMRNetwork3Name();
+
+	if (id == 0U)
+		id = m_repeater->getId();
+
+	LogInfo("DMR Network 3 Parameters");
+	LogInfo("    Name: %s", m_dmr2Name.c_str());
+	LogInfo("    Id: %u", id);
+	LogInfo("    Address: %s", address.c_str());
+	LogInfo("    Port: %u", port);
+	if (local > 0U)
+		LogInfo("    Local: %u", local);
+	else
+		LogInfo("    Local: random");
+	LogInfo("    Location Data: %s", location ? "yes" : "no");
+
+	m_dmrNetwork3 = new CDMRNetwork(address, port, local, id, password, m_dmr3Name, debug);
+
+	std::string options = m_conf.getDMRNetwork3Options();
+	if (options.empty())
+		options = m_repeater->getOptions();
+
+	if (!options.empty()) {
+		LogInfo("    Options: %s", options.c_str());
+		m_dmrNetwork3->setOptions(options);
+	}
+
+	unsigned char config[400U];
+	unsigned int len = getConfig(m_dmr3Name, config);
+
+	if (!location)
+		::memcpy(config + 30U, "0.00000000.000000", 17U);
+
+	m_dmrNetwork3->setConfig(config, len);
+
+	bool ret = m_dmrNetwork3->open();
+	if (!ret) {
+		delete m_dmrNetwork3;
+		m_dmrNetwork3 = NULL;
+		return false;
+	}
+
+	std::vector<CTGRewriteStruct> tgRewrites = m_conf.getDMRNetwork3TGRewrites();
+	for (std::vector<CTGRewriteStruct>::const_iterator it = tgRewrites.begin(); it != tgRewrites.end(); ++it) {
+		if ((*it).m_range == 1)
+			LogInfo("    Rewrite RF: %u:TG%u -> %u:TG%u", (*it).m_fromSlot, (*it).m_fromTG, (*it).m_toSlot, (*it).m_toTG);
+		else
+			LogInfo("    Rewrite RF: %u:TG%u-TG%u -> %u:TG%u-TG%u", (*it).m_fromSlot, (*it).m_fromTG, (*it).m_fromTG + (*it).m_range - 1U, (*it).m_toSlot, (*it).m_toTG, (*it).m_toTG + (*it).m_range - 1U);
+		if ((*it).m_range == 1)
+			LogInfo("    Rewrite Net: %u:TG%u -> %u:TG%u", (*it).m_toSlot, (*it).m_toTG, (*it).m_fromSlot, (*it).m_fromTG);
+		else
+			LogInfo("    Rewrite Net: %u:TG%u-TG%u -> %u:TG%u-TG%u", (*it).m_toSlot, (*it).m_toTG, (*it).m_toTG + (*it).m_range - 1U, (*it).m_fromSlot, (*it).m_fromTG, (*it).m_fromTG + (*it).m_range - 1U);
+
+		CRewriteTG* rfRewrite = new CRewriteTG(m_dmr3Name, (*it).m_fromSlot, (*it).m_fromTG, (*it).m_toSlot, (*it).m_toTG, (*it).m_range);
+		CRewriteTG* netRewrite = new CRewriteTG(m_dmr3Name, (*it).m_toSlot, (*it).m_toTG, (*it).m_fromSlot, (*it).m_fromTG, (*it).m_range);
+
+		m_dmr3RFRewrites.push_back(rfRewrite);
+		m_dmr3NetRewrites.push_back(netRewrite);
+	}
+
+	std::vector<CPCRewriteStruct> pcRewrites = m_conf.getDMRNetwork3PCRewrites();
+	for (std::vector<CPCRewriteStruct>::const_iterator it = pcRewrites.begin(); it != pcRewrites.end(); ++it) {
+		if ((*it).m_range == 1)
+			LogInfo("    Rewrite RF: %u:%u -> %u:%u", (*it).m_fromSlot, (*it).m_fromId, (*it).m_toSlot, (*it).m_toId);
+		else
+			LogInfo("    Rewrite RF: %u:%u-%u -> %u:%u-%u", (*it).m_fromSlot, (*it).m_fromId, (*it).m_fromId + (*it).m_range - 1U, (*it).m_toSlot, (*it).m_toId, (*it).m_toId + (*it).m_range - 1U);
+
+		CRewritePC* rewrite = new CRewritePC(m_dmr3Name, (*it).m_fromSlot, (*it).m_fromId, (*it).m_toSlot, (*it).m_toId, (*it).m_range);
+
+		m_dmr3RFRewrites.push_back(rewrite);
+	}
+
+	std::vector<CTypeRewriteStruct> typeRewrites = m_conf.getDMRNetwork3TypeRewrites();
+	for (std::vector<CTypeRewriteStruct>::const_iterator it = typeRewrites.begin(); it != typeRewrites.end(); ++it) {
+		LogInfo("    Rewrite RF: %u:TG%u -> %u:%u", (*it).m_fromSlot, (*it).m_fromTG, (*it).m_toSlot, (*it).m_toId);
+
+		CRewriteType* rewrite = new CRewriteType(m_dmr3Name, (*it).m_fromSlot, (*it).m_fromTG, (*it).m_toSlot, (*it).m_toId);
+
+		m_dmr3RFRewrites.push_back(rewrite);
+	}
+
+	std::vector<CSrcRewriteStruct> srcRewrites = m_conf.getDMRNetwork3SrcRewrites();
+	for (std::vector<CSrcRewriteStruct>::const_iterator it = srcRewrites.begin(); it != srcRewrites.end(); ++it) {
+		if ((*it).m_range == 1)
+			LogInfo("    Rewrite Net: %u:%u -> %u:TG%u", (*it).m_fromSlot, (*it).m_fromId, (*it).m_toSlot, (*it).m_toTG);
+		else
+			LogInfo("    Rewrite Net: %u:%u-%u -> %u:TG%u", (*it).m_fromSlot, (*it).m_fromId, (*it).m_fromId + (*it).m_range - 1U, (*it).m_toSlot, (*it).m_toTG);
+
+		CRewriteSrc* rewrite = new CRewriteSrc(m_dmr3Name, (*it).m_fromSlot, (*it).m_fromId, (*it).m_toSlot, (*it).m_toTG, (*it).m_range);
+
+		m_dmr3NetRewrites.push_back(rewrite);
+	}
+
+	std::vector<unsigned int> tgPassAll = m_conf.getDMRNetwork3PassAllTG();
+	for (std::vector<unsigned int>::const_iterator it = tgPassAll.begin(); it != tgPassAll.end(); ++it) {
+		LogInfo("    Pass All TG: %u", *it);
+
+		CPassAllTG* rfPassAllTG = new CPassAllTG(m_dmr3Name, *it);
+		CPassAllTG* netPassAllTG = new CPassAllTG(m_dmr3Name, *it);
+
+		m_dmr3Passalls.push_back(rfPassAllTG);
+		m_dmr3NetRewrites.push_back(netPassAllTG);
+	}
+
+	std::vector<unsigned int> pcPassAll = m_conf.getDMRNetwork3PassAllPC();
+	for (std::vector<unsigned int>::const_iterator it = pcPassAll.begin(); it != pcPassAll.end(); ++it) {
+		LogInfo("    Pass All PC: %u", *it);
+
+		CPassAllPC* rfPassAllPC = new CPassAllPC(m_dmr3Name, *it);
+		CPassAllPC* netPassAllPC = new CPassAllPC(m_dmr3Name, *it);
+
+		m_dmr3Passalls.push_back(rfPassAllPC);
+		m_dmr3NetRewrites.push_back(netPassAllPC);
+	}
+
+	return true;
+}
+
 bool CDMRGateway::createXLXNetwork()
 {
 	std::string fileName    = m_conf.getXLXNetworkFile();

DMRGateway.h

@@ -47,6 +47,8 @@ private:
 	std::string        m_dmr1Name;
 	CDMRNetwork*       m_dmrNetwork2;
 	std::string        m_dmr2Name;
+	CDMRNetwork*       m_dmrNetwork3;
+	std::string        m_dmr3Name;
 	CReflectors*       m_xlxReflectors;
 	CDMRNetwork*       m_xlxNetwork;
 	unsigned int       m_xlxId;
@@ -69,12 +71,16 @@ private:
 	std::vector<CRewrite*> m_dmr1RFRewrites;
 	std::vector<CRewrite*> m_dmr2NetRewrites;
 	std::vector<CRewrite*> m_dmr2RFRewrites;
+	std::vector<CRewrite*> m_dmr3NetRewrites;
+	std::vector<CRewrite*> m_dmr3RFRewrites;
 	std::vector<CRewrite*> m_dmr1Passalls;
 	std::vector<CRewrite*> m_dmr2Passalls;
+	std::vector<CRewrite*> m_dmr3Passalls;
 
 	bool createMMDVM();
 	bool createDMRNetwork1();
 	bool createDMRNetwork2();
+	bool createDMRNetwork3();
 	bool createXLXNetwork();
 
 	bool linkXLX(unsigned int number);

DMRGateway.ini

@@ -92,3 +92,16 @@ PassAllTG=2
 Password=PASSWORD
 Location=0
 Debug=0
+
+# Local HBLink network
+[DMR Network 2]
+Enabled=0
+Name=HBLink
+Address=44.131.4.2
+Port=55555
+# Local=3352
+# Local area TG on to slot 2 TG11
+TGRewrite=2,11,2,11,1
+Password=PASSWORD
+Location=0
+Debug=0