Update README.md

Merge Reporting features

.gitignore

@@ -9,6 +9,10 @@ Icon
 hblink.cfg
 hb_routing_rules.py
 hb_confbridge_rules.py
+hb_bridge_all_rules.py
+sub_acl.py
+reg_acl.py
+*.csv
 *.config
 *.json
 *.pickle

README.md

@@ -1,9 +1,7 @@
 ---
-### FOR SUPPORT, DISCUSSION, GETTING INVOLVED ###
+### THIS SOFTWARE IS DEPRECIATED -- SEE HBLINK3 ###
 
-Please join the DVSwitch group at groups.io for online forum support, discussion, and to become part of the development team.
-
-DVSwitch@groups.io 
+This version is maintained for historical purposes and for the HB_Bridge branch, which is still very much in use. HB_Bridge is the only branch that should be used. Do not file pull requests, issues or otherwise request features or fixes through github, to the author, or on any online forums.
 
 ---
 
@@ -19,10 +17,10 @@ For those who will ask: This is a piece of software that implements an open-sour
 This work represents the author's interpretation of the HomeBrew Repeater Protocol, based on the 2015-07-26 documents from DMRplus, "IPSC Protocol Specs for homebrew DMR repeater" as written by Jonathan Naylor, G4KLX; Hans Barthen, DL5DI; Torsten Shultze, DG1HT, also licenced under Creative Commons BY-NC-SA license.
 
 **WARRANTY**
-None. The owners of this work make absolutley no warranty, express or implied. Use this software at your own risk.
+None. The owners of this work make absolutely no warranty, express or implied. Use this software at your own risk.
 
 **PRE-REQUISITE KNOWLEDGE:**  
-This document assumes the reader is familiar with the Python programming language and DMR.  
+This document assumes the reader is familiar with Linux/UNIX, the Python programming language and DMR.  
 
 **MORE DOCUMENTATION TO COME**
 

hb_bridge_all.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 #
 ###############################################################################
-#   Copyright (C) 2016  Cortney T. Buffington, N0MJS <n0mjs@me.com>
+#   Copyright (C) 2016-2018 Cortney T. Buffington, N0MJS <n0mjs@me.com>
 #
 #   This program is free software; you can redistribute it and/or modify
 #   it under the terms of the GNU General Public License as published by
@@ -37,23 +37,29 @@ import sys
 from bitarray import bitarray
 from time import time
 from importlib import import_module
+from types import ModuleType
 
 # Twisted is pretty important, so I keep it separate
-from twisted.internet.protocol import DatagramProtocol
-from twisted.internet import reactor
-from twisted.internet import task
+from twisted.internet.protocol import Factory, Protocol
+from twisted.protocols.basic import NetstringReceiver
+from twisted.internet import reactor, task
 
 # Things we import from the main hblink module
-from hblink import HBSYSTEM, systems, int_id, hblink_handler
+from hblink import HBSYSTEM, OPENBRIDGE, systems, hblink_handler, reportFactory, REPORT_OPCODES, config_reports, mk_aliases
 from dmr_utils.utils import hex_str_3, int_id, get_alias
 from dmr_utils import decode, bptc, const
 import hb_config
 import hb_log
 import hb_const
 
+# The module needs logging logging, but handlers, etc. are controlled by the parent
+import logging
+logger = logging.getLogger(__name__)
+
+
 # Does anybody read this stuff? There's a PEP somewhere that says I should do this.
 __author__     = 'Cortney T. Buffington, N0MJS'
-__copyright__  = 'Copyright (c) 2016 Cortney T. Buffington, N0MJS and the K0USY Group'
+__copyright__  = 'Copyright (c) 2016-2018 Cortney T. Buffington, N0MJS and the K0USY Group'
 __credits__    = 'Colin Durbridge, G4EML, Steve Zingman, N4IRS; Mike Zingman, N4IRR; Jonathan Naylor, G4KLX; Hans Barthen, DL5DI; Torsten Shultze, DG1HT'
 __license__    = 'GNU GPLv3'
 __maintainer__ = 'Cort Buffington, N0MJS'
@@ -65,8 +71,8 @@ __status__     = 'pre-alpha'
 
 class bridgeallSYSTEM(HBSYSTEM):
     
-    def __init__(self, _name, _config, _logger):
-        HBSYSTEM.__init__(self, _name, _config, _logger)
+    def __init__(self, _name, _config, _report):
+        HBSYSTEM.__init__(self, _name, _config, _report)
         
         # Status information for the system, TS1 & TS2
         # 1 & 2 are "timeslot"
@@ -118,7 +124,7 @@ class bridgeallSYSTEM(HBSYSTEM):
                 }
             }
 
-    def dmrd_received(self, _radio_id, _rf_src, _dst_id, _seq, _slot, _call_type, _frame_type, _dtype_vseq, _stream_id, _data):
+    def dmrd_received(self, _peer_id, _rf_src, _dst_id, _seq, _slot, _call_type, _frame_type, _dtype_vseq, _stream_id, _data):
         pkt_time = time()
         dmrpkt = _data[20:53]
         _bits = int_id(_data[15])
@@ -128,20 +134,14 @@ class bridgeallSYSTEM(HBSYSTEM):
             # Is this is a new call stream?
             if (_stream_id != self.STATUS[_slot]['RX_STREAM_ID']):
                 self.STATUS['RX_START'] = pkt_time
-                self._logger.info('(%s) *CALL START* STREAM ID: %s SUB: %s (%s) REPEATER: %s (%s) TGID %s (%s), TS %s', \
-                        self._system, int_id(_stream_id), get_alias(_rf_src, subscriber_ids), int_id(_rf_src), get_alias(_radio_id, peer_ids), int_id(_radio_id), get_alias(_dst_id, talkgroup_ids), int_id(_dst_id), _slot)
-            
-            for _target in self._CONFIG['SYSTEMS']: 
-                    if _target != self._system:
-                        systems[_target].send_system(_data)
-                        self._logger.debug('(%s) Packet routed to system: %s', self._system, _target)
-            
+                logger.info('(%s) *CALL START* STREAM ID: %s SUB: %s (%s) PEER: %s (%s) TGID %s (%s), TS %s', \
+                        self._system, int_id(_stream_id), get_alias(_rf_src, subscriber_ids), int_id(_rf_src), get_alias(_peer_id, peer_ids), int_id(_peer_id), get_alias(_dst_id, talkgroup_ids), int_id(_dst_id), _slot)
             
             # Final actions - Is this a voice terminator?
             if (_frame_type == hb_const.HBPF_DATA_SYNC) and (_dtype_vseq == hb_const.HBPF_SLT_VTERM) and (self.STATUS[_slot]['RX_TYPE'] != hb_const.HBPF_SLT_VTERM):
                 call_duration = pkt_time - self.STATUS['RX_START']
-                self._logger.info('(%s) *CALL END*   STREAM ID: %s SUB: %s (%s) REPEATER: %s (%s) TGID %s (%s), TS %s, Duration: %s', \
-                        self._system, int_id(_stream_id), get_alias(_rf_src, subscriber_ids), int_id(_rf_src), get_alias(_radio_id, peer_ids), int_id(_radio_id), get_alias(_dst_id, talkgroup_ids), int_id(_dst_id), _slot, call_duration)
+                logger.info('(%s) *CALL END*   STREAM ID: %s SUB: %s (%s) PEER: %s (%s) TGID %s (%s), TS %s, Duration: %s', \
+                        self._system, int_id(_stream_id), get_alias(_rf_src, subscriber_ids), int_id(_rf_src), get_alias(_peer_id, peer_ids), int_id(_peer_id), get_alias(_dst_id, talkgroup_ids), int_id(_dst_id), _slot, call_duration)
             
             # Mark status variables for use later
             self.STATUS[_slot]['RX_RFS']       = _rf_src
@@ -149,6 +149,52 @@ class bridgeallSYSTEM(HBSYSTEM):
             self.STATUS[_slot]['RX_TGID']      = _dst_id
             self.STATUS[_slot]['RX_TIME']      = pkt_time
             self.STATUS[_slot]['RX_STREAM_ID'] = _stream_id
+            
+            
+            for _target in self._CONFIG['SYSTEMS']: 
+                    if _target != self._system:
+                        
+                        _target_status = systems[_target].STATUS
+                        _target_system = self._CONFIG['SYSTEMS'][_target]
+                        _target_status[_slot]['TX_STREAM_ID'] = _stream_id
+                            
+                        # ACL Processing
+                        if self._CONFIG['GLOBAL']['USE_ACL']:
+                            if not acl_check(_rf_src, self._CONFIG['GLOBAL']['SUB_ACL']):
+                                if self._laststrid != _stream_id:
+                                    logger.debug('(%s) CALL DROPPED ON EGRESS WITH STREAM ID %s FROM SUBSCRIBER %s BY GLOBAL ACL', _target_system, int_id(_stream_id), int_id(_rf_src))
+                                    self._laststrid = _stream_id
+                                return
+                            if _slot == 1 and not acl_check(_dst_id, self._CONFIG['GLOBAL']['TG1_ACL']):
+                                if self._laststrid != _stream_id:
+                                    logger.debug('(%s) CALL DROPPED ON EGRESS WITH STREAM ID %s ON TGID %s BY GLOBAL TS1 ACL', _target_system, int_id(_stream_id), int_id(_dst_id))
+                                    self._laststrid = _stream_id
+                                return
+                            if _slot == 2 and not acl_check(_dst_id, self._CONFIG['GLOBAL']['TG2_ACL']):
+                                if self._laststrid != _stream_id:
+                                    logger.debug('(%s) CALL DROPPED ON EGRESS WITH STREAM ID %s ON TGID %s BY GLOBAL TS2 ACL', _target_system, int_id(_stream_id), int_id(_dst_id))
+                                    self._laststrid = _stream_id
+                                return
+                        if self._target_system['USE_ACL']:
+                            if not acl_check(_rf_src, _target_system['SUB_ACL']):
+                                if self._laststrid != _stream_id:
+                                    logger.debug('(%s) CALL DROPPED ON EGRESS WITH STREAM ID %s FROM SUBSCRIBER %s BY SYSTEM ACL', _target_system, int_id(_stream_id), int_id(_rf_src))
+                                    self._laststrid = _stream_id
+                                return
+                            if _slot == 1 and not acl_check(_dst_id, _target_system['TG1_ACL']):
+                                if self._laststrid != _stream_id:
+                                    logger.debug('(%s) CALL DROPPED ON EGRESS WITH STREAM ID %s ON TGID %s BY SYSTEM TS1 ACL', _target_system, int_id(_stream_id), int_id(_dst_id))
+                                    self._laststrid = _stream_id
+                                return
+                            if _slot == 2 and not acl_check(_dst_id, _target_system['TG2_ACL']):
+                                if self._laststrid != _stream_id:
+                                    logger.debug('(%s) CALL DROPPED ON EGRESS WITH STREAM ID %s ON TGID %s BY SYSTEM TS2 ACL', _target_system, int_id(_stream_id), int_id(_dst_id))
+                                    self._laststrid = _stream_id
+                                return
+                        self._laststrid = _stream_id
+                        
+                        systems[_target].send_system(_data)
+                        #logger.debug('(%s) Packet routed to system: %s', self._system, _target)
                 
 
 #************************************************
@@ -156,7 +202,6 @@ class bridgeallSYSTEM(HBSYSTEM):
 #************************************************
 
 if __name__ == '__main__':
-    
     import argparse
     import sys
     import os
@@ -183,49 +228,36 @@ if __name__ == '__main__':
     if cli_args.LOG_LEVEL:
         CONFIG['LOGGER']['LOG_LEVEL'] = cli_args.LOG_LEVEL
     logger = hb_log.config_logging(CONFIG['LOGGER'])
+    logger.info('\n\nCopyright (c) 2013, 2014, 2015, 2016, 2018\n\tThe Founding Members of the K0USY Group. All rights reserved.\n')
     logger.debug('Logging system started, anything from here on gets logged')
     
     # Set up the signal handler
     def sig_handler(_signal, _frame):
         logger.info('SHUTDOWN: HBROUTER IS TERMINATING WITH SIGNAL %s', str(_signal))
-        hblink_handler(_signal, _frame, logger)
+        hblink_handler(_signal, _frame)
         logger.info('SHUTDOWN: ALL SYSTEM HANDLERS EXECUTED - STOPPING REACTOR')
         reactor.stop()
         
     # Set signal handers so that we can gracefully exit if need be
     for sig in [signal.SIGTERM, signal.SIGINT]:
         signal.signal(sig, sig_handler)
-    
-    # ID ALIAS CREATION
-    # Download
-    if CONFIG['ALIASES']['TRY_DOWNLOAD'] == True:
-        # Try updating peer aliases file
-        result = try_download(CONFIG['ALIASES']['PATH'], CONFIG['ALIASES']['PEER_FILE'], CONFIG['ALIASES']['PEER_URL'], CONFIG['ALIASES']['STALE_TIME'])
-        logger.info(result)
-        # Try updating subscriber aliases file
-        result = try_download(CONFIG['ALIASES']['PATH'], CONFIG['ALIASES']['SUBSCRIBER_FILE'], CONFIG['ALIASES']['SUBSCRIBER_URL'], CONFIG['ALIASES']['STALE_TIME'])
-        logger.info(result)
-        
-    # Make Dictionaries
-    peer_ids = mk_id_dict(CONFIG['ALIASES']['PATH'], CONFIG['ALIASES']['PEER_FILE'])
-    if peer_ids:
-        logger.info('ID ALIAS MAPPER: peer_ids dictionary is available')
-        
-    subscriber_ids = mk_id_dict(CONFIG['ALIASES']['PATH'], CONFIG['ALIASES']['SUBSCRIBER_FILE'])
-    if subscriber_ids:
-        logger.info('ID ALIAS MAPPER: subscriber_ids dictionary is available')
-    
-    talkgroup_ids = mk_id_dict(CONFIG['ALIASES']['PATH'], CONFIG['ALIASES']['TGID_FILE'])
-    if talkgroup_ids:
-        logger.info('ID ALIAS MAPPER: talkgroup_ids dictionary is available')
-        
-    
+
+    # Create the name-number mapping dictionaries
+    peer_ids, subscriber_ids, talkgroup_ids = mk_aliases(CONFIG)
+
+    # INITIALIZE THE REPORTING LOOP
+    report_server = config_reports(CONFIG, reportFactory)
+
     # HBlink instance creation
-    logger.info('HBlink \'hb_bridge_all.py\' (c) 2016 N0MJS & the K0USY Group - SYSTEM STARTING...')
+    logger.info('HBlink \'hb_bridge_all.py\' -- SYSTEM STARTING...')
     for system in CONFIG['SYSTEMS']:
         if CONFIG['SYSTEMS'][system]['ENABLED']:
-            systems[system] = bridgeallSYSTEM(system, CONFIG, logger)
+            if CONFIG['SYSTEMS'][system]['MODE'] == 'OPENBRIDGE':
+                logger.critical('%s FATAL: Instance is mode \'OPENBRIDGE\', \n\t\t...Which would be tragic for Bridge All, since it carries multiple call\n\t\tstreams simultaneously. hb_bridge_all.py onlyl works with MMDVM-based systems', system)
+                sys.exit('hb_bridge_all.py cannot function with systems that are not MMDVM devices. System {} is configured as an OPENBRIDGE'.format(system))
+            else:
+                systems[system] = bridgeallSYSTEM(system, CONFIG, report_server)
             reactor.listenUDP(CONFIG['SYSTEMS'][system]['PORT'], systems[system], interface=CONFIG['SYSTEMS'][system]['IP'])
             logger.debug('%s instance created: %s, %s', CONFIG['SYSTEMS'][system]['MODE'], system, systems[system])
 
-    reactor.run()
+    reactor.run()

hb_confbridge.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 #
 ###############################################################################
-#   Copyright (C) 2016  Cortney T. Buffington, N0MJS <n0mjs@me.com>
+#   Copyright (C) 2016-2018 Cortney T. Buffington, N0MJS <n0mjs@me.com>
 #
 #   This program is free software; you can redistribute it and/or modify
 #   it under the terms of the GNU General Public License as published by
@@ -40,32 +40,61 @@ from time import time
 from importlib import import_module
 
 # Twisted is pretty important, so I keep it separate
-from twisted.internet.protocol import DatagramProtocol
-from twisted.internet import reactor
-from twisted.internet import task
+from twisted.internet.protocol import Factory, Protocol
+from twisted.protocols.basic import NetstringReceiver
+from twisted.internet import reactor, task
 
 # Things we import from the main hblink module
-from hblink import HBSYSTEM, systems, hblink_handler
+from hblink import HBSYSTEM, OPENBRIDGE, systems, hblink_handler, reportFactory, REPORT_OPCODES, mk_aliases
 from dmr_utils.utils import hex_str_3, int_id, get_alias
 from dmr_utils import decode, bptc, const
 import hb_config
 import hb_log
 import hb_const
 
+# Stuff for socket reporting
+import cPickle as pickle
+from datetime import datetime
+# The module needs logging logging, but handlers, etc. are controlled by the parent
+import logging
+logger = logging.getLogger(__name__)
+
+
 # Does anybody read this stuff? There's a PEP somewhere that says I should do this.
 __author__     = 'Cortney T. Buffington, N0MJS'
-__copyright__  = 'Copyright (c) 2016 Cortney T. Buffington, N0MJS and the K0USY Group'
+__copyright__  = 'Copyright (c) 2016-2018 Cortney T. Buffington, N0MJS and the K0USY Group'
 __credits__    = 'Colin Durbridge, G4EML, Steve Zingman, N4IRS; Mike Zingman, N4IRR; Jonathan Naylor, G4KLX; Hans Barthen, DL5DI; Torsten Shultze, DG1HT'
 __license__    = 'GNU GPLv3'
 __maintainer__ = 'Cort Buffington, N0MJS'
 __email__      = 'n0mjs@me.com'
-__status__     = 'pre-alpha'
 
 # Module gobal varaibles
 
+# Timed loop used for reporting HBP status
+#
+# REPORT BASED ON THE TYPE SELECTED IN THE MAIN CONFIG FILE
+def config_reports(_config, _factory):
+    if True: #_config['REPORTS']['REPORT']:
+        def reporting_loop(logger, _server):
+            logger.debug('Periodic reporting loop started')
+            _server.send_config()
+            _server.send_bridge()
+
+        logger.info('HBlink TCP reporting server configured')
+
+        report_server = _factory(_config)
+        report_server.clients = []
+        reactor.listenTCP(_config['REPORTS']['REPORT_PORT'], report_server)
+
+        reporting = task.LoopingCall(reporting_loop, logger, report_server)
+        reporting.start(_config['REPORTS']['REPORT_INTERVAL'])
+
+    return report_server
+
+
 # Import Bridging rules
 # Note: A stanza *must* exist for any MASTER or CLIENT configured in the main
-# configuration file and listed as "active". It can be empty, 
+# configuration file and listed as "active". It can be empty,
 # but it has to exist.
 def make_bridges(_hb_confbridge_bridges):
     try:
@@ -73,64 +102,30 @@ def make_bridges(_hb_confbridge_bridges):
         logger.info('Routing bridges file found and bridges imported')
     except ImportError:
         sys.exit('Routing bridges file not found or invalid')
-    
+
     # Convert integer GROUP ID numbers from the config into hex strings
     # we need to send in the actual data packets.
     for _bridge in bridge_file.BRIDGES:
         for _system in bridge_file.BRIDGES[_bridge]:
             if _system['SYSTEM'] not in CONFIG['SYSTEMS']:
                 sys.exit('ERROR: Conference bridges found for system not configured main configuration')
-                
+
             _system['TGID']       = hex_str_3(_system['TGID'])
             for i, e in enumerate(_system['ON']):
                 _system['ON'][i]  = hex_str_3(_system['ON'][i])
             for i, e in enumerate(_system['OFF']):
                 _system['OFF'][i] = hex_str_3(_system['OFF'][i])
             _system['TIMEOUT']    = _system['TIMEOUT']*60
-            _system['TIMER']      = time() + _system['TIMEOUT']
-
+            if _system['ACTIVE'] == True:
+                _system['TIMER']  = time() + _system['TIMEOUT']
+            else:
+                _system['TIMER']  = time()
     return bridge_file.BRIDGES
 
 
-# Import subscriber ACL
-# ACL may be a single list of subscriber IDs
-# Global action is to allow or deny them. Multiple lists with different actions and ranges
-# are not yet implemented.
-def build_acl(_sub_acl):
-    try:
-        acl_file = import_module(_sub_acl)
-        for i, e in enumerate(acl_file.ACL):
-            acl_file.ACL[i] = hex_str_3(acl_file.ACL[i])
-        logger.info('ACL file found and ACL entries imported')
-    except ImportError:
-        logger.info('ACL file not found or invalid - all subscriber IDs are valid')
-        ACL_ACTION = 'NONE'
-
-    # Depending on which type of ACL is used (PERMIT, DENY... or there isn't one)
-    # define a differnet function to be used to check the ACL
-    global allow_sub
-    if acl_file.ACL_ACTION == 'PERMIT':
-        def allow_sub(_sub):
-            if _sub in ACL:
-                return True
-            else:
-                return False
-    elif acl_file.ACL_ACTION == 'DENY':
-        def allow_sub(_sub):
-            if _sub not in ACL:
-                return True
-            else:
-                return False
-    else:
-        def allow_sub(_sub):
-            return True
-    
-    return acl_file.ACL
-
-
 # Run this every minute for rule timer updates
 def rule_timer_loop():
-    logger.info('(ALL HBSYSTEMS) Rule timer loop started')
+    logger.debug('(ALL HBSYSTEMS) Rule timer loop started')
     _now = time()
 
     for _bridge in BRIDGES:
@@ -158,21 +153,272 @@ def rule_timer_loop():
             else:
                 logger.debug('Conference Bridge NO ACTION: System: %s, Bridge: %s, TS: %s, TGID: %s', _system['SYSTEM'], _bridge, _system['TS'], int_id(_system['TGID']))
 
+    if CONFIG['REPORTS']['REPORT']:
+        report_server.send_clients('bridge updated')
+
+
+# run this every 10 seconds to trim orphaned stream ids
+def stream_trimmer_loop():
+    logger.debug('(ALL OPENBRIDGE SYSTEMS) Trimming inactive stream IDs from system lists')
+    _now = time()
+
+    for system in systems:
+        # HBP systems, master and peer
+        if CONFIG['SYSTEMS'][system]['MODE'] != 'OPENBRIDGE':
+            for slot in range(1,3):
+                _slot  = systems[system].STATUS[slot]
+                if _slot['RX_TYPE'] != hb_const.HBPF_SLT_VTERM and _slot['RX_TIME'] <  _now - 5:
+                    _slot['RX_TYPE'] = hb_const.HBPF_SLT_VTERM
+                    logger.info('(%s) *TIME OUT*  RX STREAM ID: %s SUB: %s TGID %s, TS %s, Duration: %s', \
+                        system, int_id(_slot['RX_STREAM_ID']), int_id(_slot['RX_RFS']), int_id(_slot['RX_TGID']), slot, _slot['RX_TIME'] - _slot['RX_START'])
+                    if CONFIG['REPORTS']['REPORT']:
+                        systems[system]._report.send_bridgeEvent('GROUP VOICE,END,RX,{},{},{},{},{},{},{:.2f}'.format(system, int_id(_slot['RX_STREAM_ID']), int_id(_slot['RX_PEER']), int_id(_slot['RX_RFS']), slot, int_id(_slot['RX_TGID']), _slot['RX_TIME'] - _slot['RX_START']))
+
+            for slot in range(1,3):
+                _slot  = systems[system].STATUS[slot]
+                if _slot['TX_TYPE'] != hb_const.HBPF_SLT_VTERM and _slot['TX_TIME'] <  _now - 5:
+                    _slot['TX_TYPE'] = hb_const.HBPF_SLT_VTERM
+                    logger.info('(%s) *TIME OUT*  TX STREAM ID: %s SUB: %s TGID %s, TS %s, Duration: %s', \
+                        system, int_id(_slot['TX_STREAM_ID']), int_id(_slot['TX_RFS']), int_id(_slot['TX_TGID']), slot, _slot['TX_TIME'] - _slot['TX_START'])
+                    if CONFIG['REPORTS']['REPORT']:
+                        systems[system]._report.send_bridgeEvent('GROUP VOICE,END,TX,{},{},{},{},{},{},{:.2f}'.format(system, int_id(_slot['TX_STREAM_ID']), int_id(_slot['TX_PEER']), int_id(_slot['TX_RFS']), slot, int_id(_slot['TX_TGID']), _slot['TX_TIME'] - _slot['TX_START']))
+
+        # OBP systems
+        # We can't delete items from a dicationry that's being iterated, so we have to make a temporarly list of entrys to remove later
+        if CONFIG['SYSTEMS'][system]['MODE'] == 'OPENBRIDGE':
+            remove_list = []
+            for stream_id in systems[system].STATUS:
+                if systems[system].STATUS[stream_id]['LAST'] < _now - 5:
+                    remove_list.append(stream_id)
+            for stream_id in remove_list:
+                if stream_id in systems[system].STATUS:
+                    _system = systems[system].STATUS[stream_id]
+                    _config = CONFIG['SYSTEMS'][system]
+                    logger.info('(%s) *TIME OUT*   STREAM ID: %s SUB: %s PEER: %s TGID: %s TS 1 Duration: %s', \
+                        system, int_id(stream_id), get_alias(int_id(_system['RFS']), subscriber_ids), get_alias(int_id(_config['NETWORK_ID']), peer_ids), get_alias(int_id(_system['TGID']), talkgroup_ids), _system['LAST'] - _system['START'])
+                    if CONFIG['REPORTS']['REPORT']:
+                            systems[system]._report.send_bridgeEvent('GROUP VOICE,END,RX,{},{},{},{},{},{},{:.2f}'.format(system, int_id(stream_id), int_id(_config['NETWORK_ID']), int_id(_system['RFS']), 1, int_id(_system['TGID']), _system['LAST'] - _system['START']))
+                    removed = systems[system].STATUS.pop(stream_id)
+                else:
+                    logger.error('(%s) Attemped to remove OpenBridge Stream ID %s not in the Stream ID list: %s', system, int_id(stream_id), [id for id in systems[system].STATUS])
+
+class routerOBP(OPENBRIDGE):
+
+    def __init__(self, _name, _config, _report):
+        OPENBRIDGE.__init__(self, _name, _config, _report)
+        self.STATUS = {}
+
+
+    def dmrd_received(self, _peer_id, _rf_src, _dst_id, _seq, _slot, _call_type, _frame_type, _dtype_vseq, _stream_id, _data):
+        pkt_time = time()
+        dmrpkt = _data[20:53]
+        _bits = int_id(_data[15])
+
+        if _call_type == 'group':
+            # Is this a new call stream?
+            if (_stream_id not in self.STATUS):
+                # This is a new call stream
+                self.STATUS[_stream_id] = {
+                    'START':     pkt_time,
+                    'CONTENTION':False,
+                    'RFS':       _rf_src,
+                    'TGID':      _dst_id,
+                }
+
+                # If we can, use the LC from the voice header as to keep all options intact
+                if _frame_type == hb_const.HBPF_DATA_SYNC and _dtype_vseq == hb_const.HBPF_SLT_VHEAD:
+                    decoded = decode.voice_head_term(dmrpkt)
+                    self.STATUS[_stream_id]['LC'] = decoded['LC']
+
+                # If we don't have a voice header then don't wait to decode the Embedded LC
+                # just make a new one from the HBP header. This is good enough, and it saves lots of time
+                else:
+                    self.STATUS[_stream_id]['LC'] = const.LC_OPT + _dst_id + _rf_src
+
+
+                logger.info('(%s) *CALL START* STREAM ID: %s SUB: %s (%s) PEER: %s (%s) TGID %s (%s), TS %s', \
+                        self._system, int_id(_stream_id), get_alias(_rf_src, subscriber_ids), int_id(_rf_src), get_alias(_peer_id, peer_ids), int_id(_peer_id), get_alias(_dst_id, talkgroup_ids), int_id(_dst_id), _slot)
+                if CONFIG['REPORTS']['REPORT']:
+                    self._report.send_bridgeEvent('GROUP VOICE,START,RX,{},{},{},{},{},{}'.format(self._system, int_id(_stream_id), int_id(_peer_id), int_id(_rf_src), _slot, int_id(_dst_id)))
+
+            self.STATUS[_stream_id]['LAST'] = pkt_time
+
+
+            for _bridge in BRIDGES:
+                for _system in BRIDGES[_bridge]:
+
+                    if (_system['SYSTEM'] == self._system and _system['TGID'] == _dst_id and _system['TS'] == _slot and _system['ACTIVE'] == True):
+
+                        for _target in BRIDGES[_bridge]:
+                            if (_target['SYSTEM'] != self._system) and (_target['ACTIVE']):
+                                _target_status = systems[_target['SYSTEM']].STATUS
+                                _target_system = self._CONFIG['SYSTEMS'][_target['SYSTEM']]
+                                if _target_system['MODE'] == 'OPENBRIDGE':
+                                    # Is this a new call stream on the target?
+                                    if (_stream_id not in _target_status):
+                                        # This is a new call stream on the target
+                                        _target_status[_stream_id] = {
+                                            'START':     pkt_time,
+                                            'CONTENTION':False,
+                                            'RFS':       _rf_src,
+                                            'TGID':      _dst_id,
+                                        }
+                                        # Generate LCs (full and EMB) for the TX stream
+                                        dst_lc = ''.join([self.STATUS[_stream_id]['LC'][0:3], _target['TGID'], _rf_src])
+                                        _target_status[_stream_id]['H_LC'] = bptc.encode_header_lc(dst_lc)
+                                        _target_status[_stream_id]['T_LC'] = bptc.encode_terminator_lc(dst_lc)
+                                        _target_status[_stream_id]['EMB_LC'] = bptc.encode_emblc(dst_lc)
+
+                                        logger.info('(%s) Conference Bridge: %s, Call Bridged to OBP System: %s TS: %s, TGID: %s', self._system, _bridge, _target['SYSTEM'], _target['TS'], int_id(_target['TGID']))
+                                        if CONFIG['REPORTS']['REPORT']:
+                                            systems[_target['SYSTEM']]._report.send_bridgeEvent('GROUP VOICE,START,TX,{},{},{},{},{},{}'.format(_target['SYSTEM'], int_id(_stream_id), int_id(_peer_id), int_id(_rf_src), _target['TS'], int_id(_target['TGID'])))
+
+                                    # Record the time of this packet so we can later identify a stale stream
+                                    _target_status[_stream_id]['LAST'] = pkt_time
+                                    # Clear the TS bit -- all OpenBridge streams are effectively on TS1
+                                    _tmp_bits = _bits & ~(1 << 7)
+
+                                    # Assemble transmit HBP packet header
+                                    _tmp_data = _data[:8] + _target['TGID'] + _data[11:15] + chr(_tmp_bits) + _data[16:20]
+
+                                    # MUST TEST FOR NEW STREAM AND IF SO, RE-WRITE THE LC FOR THE TARGET
+                                    # MUST RE-WRITE DESTINATION TGID IF DIFFERENT
+                                    # if _dst_id != rule['DST_GROUP']:
+                                    dmrbits = bitarray(endian='big')
+                                    dmrbits.frombytes(dmrpkt)
+                                    # Create a voice header packet (FULL LC)
+                                    if _frame_type == hb_const.HBPF_DATA_SYNC and _dtype_vseq == hb_const.HBPF_SLT_VHEAD:
+                                        dmrbits = _target_status[_stream_id]['H_LC'][0:98] + dmrbits[98:166] + _target_status[_stream_id]['H_LC'][98:197]
+                                    # Create a voice terminator packet (FULL LC)
+                                    elif _frame_type == hb_const.HBPF_DATA_SYNC and _dtype_vseq == hb_const.HBPF_SLT_VTERM:
+                                        dmrbits = _target_status[_stream_id]['T_LC'][0:98] + dmrbits[98:166] + _target_status[_stream_id]['T_LC'][98:197]
+                                        if CONFIG['REPORTS']['REPORT']:
+                                            call_duration = pkt_time - _target_status[_stream_id]['START']
+                                            systems[_target['SYSTEM']]._report.send_bridgeEvent('GROUP VOICE,END,TX,{},{},{},{},{},{},{:.2f}'.format(_target['SYSTEM'], int_id(_stream_id), int_id(_peer_id), int_id(_rf_src), _target['TS'], int_id(_target['TGID']), call_duration))
+                                    # Create a Burst B-E packet (Embedded LC)
+                                    elif _dtype_vseq in [1,2,3,4]:
+                                        dmrbits = dmrbits[0:116] + _target_status[_stream_id]['EMB_LC'][_dtype_vseq] + dmrbits[148:264]
+                                    dmrpkt = dmrbits.tobytes()
+                                    _tmp_data = _tmp_data + dmrpkt #+ _data[53:55]
+
+                                else:
+                                    # BEGIN CONTENTION HANDLING
+                                    #
+                                    # The rules for each of the 4 "ifs" below are listed here for readability. The Frame To Send is:
+                                    #   From a different group than last RX from this HBSystem, but it has been less than Group Hangtime
+                                    #   From a different group than last TX to this HBSystem, but it has been less than Group Hangtime
+                                    #   From the same group as the last RX from this HBSystem, but from a different subscriber, and it has been less than stream timeout
+                                    #   From the same group as the last TX to this HBSystem, but from a different subscriber, and it has been less than stream timeout
+                                    # The "continue" at the end of each means the next iteration of the for loop that tests for matching rules
+                                    #
+                                    if ((_target['TGID'] != _target_status[_target['TS']]['RX_TGID']) and ((pkt_time - _target_status[_target['TS']]['RX_TIME']) < _target_system['GROUP_HANGTIME'])):
+                                        if self.STATUS[_stream_id]['CONTENTION'] == False:
+                                            self.STATUS[_stream_id]['CONTENTION'] = True
+                                            logger.info('(%s) Call not routed to TGID %s, target active or in group hangtime: HBSystem: %s, TS: %s, TGID: %s', self._system, int_id(_target['TGID']), _target['SYSTEM'], _target['TS'], int_id(_target_status[_target['TS']]['RX_TGID']))
+                                        continue
+                                    if ((_target['TGID'] != _target_status[_target['TS']]['TX_TGID']) and ((pkt_time - _target_status[_target['TS']]['TX_TIME']) < _target_system['GROUP_HANGTIME'])):
+                                        if self.STATUS[_stream_id]['CONTENTION'] == False:
+                                            self.STATUS[_stream_id]['CONTENTION'] = True
+                                            logger.info('(%s) Call not routed to TGID%s, target in group hangtime: HBSystem: %s, TS: %s, TGID: %s', self._system, int_id(_target['TGID']), _target['SYSTEM'], _target['TS'], int_id(_target_status[_target['TS']]['TX_TGID']))
+                                        continue
+                                    if (_target['TGID'] == _target_status[_target['TS']]['RX_TGID']) and ((pkt_time - _target_status[_target['TS']]['RX_TIME']) < hb_const.STREAM_TO):
+                                        if self.STATUS[_stream_id]['CONTENTION'] == False:
+                                            self.STATUS[_stream_id]['CONTENTION'] = True
+                                            logger.info('(%s) Call not routed to TGID%s, matching call already active on target: HBSystem: %s, TS: %s, TGID: %s', self._system, int_id(_target['TGID']), _target['SYSTEM'], _target['TS'], int_id(_target_status[_target['TS']]['RX_TGID']))
+                                        continue
+                                    if (_target['TGID'] == _target_status[_target['TS']]['TX_TGID']) and (_rf_src != _target_status[_target['TS']]['TX_RFS']) and ((pkt_time - _target_status[_target['TS']]['TX_TIME']) < hb_const.STREAM_TO):
+                                        if self.STATUS[_stream_id]['CONTENTION'] == False:
+                                            self.STATUS[_stream_id]['CONTENTION'] = True
+                                            logger.info('(%s) Call not routed for subscriber %s, call route in progress on target: HBSystem: %s, TS: %s, TGID: %s, SUB: %s', self._system, int_id(_rf_src), _target['SYSTEM'], _target['TS'], int_id(_target_status[_target['TS']]['TX_TGID']), int_id(_target_status[_target['TS']]['TX_RFS']))
+                                        continue
+
+                                    # Is this a new call stream?
+                                    if (_target_status[_target['TS']]['TX_STREAM_ID'] != _stream_id): #(_target_status[_target['TS']]['TX_RFS'] != _rf_src) or (_target_status[_target['TS']]['TX_TGID'] != _target['TGID']):
+                                    #if (_stream_id != self.STATUS[_slot]['RX_STREAM_ID']) or (_target_status[_target['TS']]['TX_RFS'] != _rf_src) or (_target_status[_target['TS']]['TX_TGID'] != _target['TGID']):
+                                        # Record the DST TGID and Stream ID
+                                        _target_status[_target['TS']]['TX_START'] = pkt_time
+                                        _target_status[_target['TS']]['TX_TGID'] = _target['TGID']
+                                        _target_status[_target['TS']]['TX_STREAM_ID'] = _stream_id
+                                        _target_status[_target['TS']]['TX_RFS'] = _rf_src
+                                        _target_status[_target['TS']]['TX_PEER'] = _peer_id
+                                        # Generate LCs (full and EMB) for the TX stream
+                                        dst_lc = self.STATUS[_stream_id]['LC'][0:3] + _target['TGID'] + _rf_src
+                                        _target_status[_target['TS']]['TX_H_LC'] = bptc.encode_header_lc(dst_lc)
+                                        _target_status[_target['TS']]['TX_T_LC'] = bptc.encode_terminator_lc(dst_lc)
+                                        _target_status[_target['TS']]['TX_EMB_LC'] = bptc.encode_emblc(dst_lc)
+                                        logger.debug('(%s) Generating TX FULL and EMB LCs for HomeBrew destination: System: %s, TS: %s, TGID: %s', self._system, _target['SYSTEM'], _target['TS'], int_id(_target['TGID']))
+                                        logger.info('(%s) Conference Bridge: %s, Call Bridged to HBP System: %s TS: %s, TGID: %s', self._system, _bridge, _target['SYSTEM'], _target['TS'], int_id(_target['TGID']))
+                                        if CONFIG['REPORTS']['REPORT']:
+                                           systems[_target['SYSTEM']]._report.send_bridgeEvent('GROUP VOICE,START,TX,{},{},{},{},{},{}'.format(_target['SYSTEM'], int_id(_stream_id), int_id(_peer_id), int_id(_rf_src), _target['TS'], int_id(_target['TGID'])))
+
+                                    # Set other values for the contention handler to test next time there is a frame to forward
+                                    _target_status[_target['TS']]['TX_TIME'] = pkt_time
+                                    _target_status[_target['TS']]['TX_TYPE'] = _dtype_vseq
+
+                                    # Handle any necessary re-writes for the destination
+                                    if _system['TS'] != _target['TS']:
+                                        _tmp_bits = _bits ^ 1 << 7
+                                    else:
+                                        _tmp_bits = _bits
+
+                                    # Assemble transmit HBP packet header
+                                    _tmp_data = _data[:8] + _target['TGID'] + _data[11:15] + chr(_tmp_bits) + _data[16:20]
+
+                                    # MUST TEST FOR NEW STREAM AND IF SO, RE-WRITE THE LC FOR THE TARGET
+                                    # MUST RE-WRITE DESTINATION TGID IF DIFFERENT
+                                    # if _dst_id != rule['DST_GROUP']:
+                                    dmrbits = bitarray(endian='big')
+                                    dmrbits.frombytes(dmrpkt)
+                                    # Create a voice header packet (FULL LC)
+                                    if _frame_type == hb_const.HBPF_DATA_SYNC and _dtype_vseq == hb_const.HBPF_SLT_VHEAD:
+                                        dmrbits = _target_status[_target['TS']]['TX_H_LC'][0:98] + dmrbits[98:166] + _target_status[_target['TS']]['TX_H_LC'][98:197]
+                                    # Create a voice terminator packet (FULL LC)
+                                    elif _frame_type == hb_const.HBPF_DATA_SYNC and _dtype_vseq == hb_const.HBPF_SLT_VTERM:
+                                        dmrbits = _target_status[_target['TS']]['TX_T_LC'][0:98] + dmrbits[98:166] + _target_status[_target['TS']]['TX_T_LC'][98:197]
+                                        if CONFIG['REPORTS']['REPORT']:
+                                            call_duration = pkt_time - _target_status[_target['TS']]['TX_START']
+                                            systems[_target['SYSTEM']]._report.send_bridgeEvent('GROUP VOICE,END,TX,{},{},{},{},{},{},{:.2f}'.format(_target['SYSTEM'], int_id(_stream_id), int_id(_peer_id), int_id(_rf_src), _target['TS'], int_id(_target['TGID']), call_duration))
+                                    # Create a Burst B-E packet (Embedded LC)
+                                    elif _dtype_vseq in [1,2,3,4]:
+                                        dmrbits = dmrbits[0:116] + _target_status[_target['TS']]['TX_EMB_LC'][_dtype_vseq] + dmrbits[148:264]
+                                    dmrpkt = dmrbits.tobytes()
+                                    _tmp_data = _tmp_data + dmrpkt + '\x00\x00' # Add two bytes of nothing since OBP doesn't include BER & RSSI bytes #_data[53:55]
+
+                                # Transmit the packet to the destination system
+                                systems[_target['SYSTEM']].send_system(_tmp_data)
+                                #logger.debug('(%s) Packet routed by bridge: %s to system: %s TS: %s, TGID: %s', self._system, _bridge, _target['SYSTEM'], _target['TS'], int_id(_target['TGID']))
+
+
+
+            # Final actions - Is this a voice terminator?
+            if (_frame_type == hb_const.HBPF_DATA_SYNC) and (_dtype_vseq == hb_const.HBPF_SLT_VTERM):
+                call_duration = pkt_time - self.STATUS[_stream_id]['START']
+                logger.info('(%s) *CALL END*   STREAM ID: %s SUB: %s (%s) PEER: %s (%s) TGID %s (%s), TS %s, Duration: %s', \
+                        self._system, int_id(_stream_id), get_alias(_rf_src, subscriber_ids), int_id(_rf_src), get_alias(_peer_id, peer_ids), int_id(_peer_id), get_alias(_dst_id, talkgroup_ids), int_id(_dst_id), _slot, call_duration)
+                if CONFIG['REPORTS']['REPORT']:
+                   self._report.send_bridgeEvent('GROUP VOICE,END,RX,{},{},{},{},{},{},{:.2f}'.format(self._system, int_id(_stream_id), int_id(_peer_id), int_id(_rf_src), _slot, int_id(_dst_id), call_duration))
+                removed = self.STATUS.pop(_stream_id)
+                logger.debug('(%s) OpenBridge sourced call stream end, remove terminated Stream ID: %s', self._system, int_id(_stream_id))
+                if not removed:
+                    selflogger.error('(%s) *CALL END*   STREAM ID: %s NOT IN LIST -- THIS IS A REAL PROBLEM', self._system, int_id(_stream_id))
+
+class routerHBP(HBSYSTEM):
+
+    def __init__(self, _name, _config, _report):
+        HBSYSTEM.__init__(self, _name, _config, _report)
 
-class routerSYSTEM(HBSYSTEM):
-    
-    def __init__(self, _name, _config, _logger):
-        HBSYSTEM.__init__(self, _name, _config, _logger)
-        
         # Status information for the system, TS1 & TS2
         # 1 & 2 are "timeslot"
         # In TX_EMB_LC, 2-5 are burst B-E
         self.STATUS = {
             1: {
                 'RX_START':     time(),
+                'TX_START':     time(),
                 'RX_SEQ':       '\x00',
                 'RX_RFS':       '\x00',
                 'TX_RFS':       '\x00',
+                'RX_PEER':      '\x00',
+                'TX_PEER':      '\x00',
                 'RX_STREAM_ID': '\x00',
                 'TX_STREAM_ID': '\x00',
                 'RX_TGID':      '\x00\x00\x00',
@@ -180,6 +426,7 @@ class routerSYSTEM(HBSYSTEM):
                 'RX_TIME':      time(),
                 'TX_TIME':      time(),
                 'RX_TYPE':      hb_const.HBPF_SLT_VTERM,
+                'TX_TYPE':      hb_const.HBPF_SLT_VTERM,
                 'RX_LC':        '\x00',
                 'TX_H_LC':      '\x00',
                 'TX_T_LC':      '\x00',
@@ -192,9 +439,12 @@ class routerSYSTEM(HBSYSTEM):
                 },
             2: {
                 'RX_START':     time(),
+                'TX_START':     time(),
                 'RX_SEQ':       '\x00',
                 'RX_RFS':       '\x00',
                 'TX_RFS':       '\x00',
+                'RX_PEER':      '\x00',
+                'TX_PEER':      '\x00',
                 'RX_STREAM_ID': '\x00',
                 'TX_STREAM_ID': '\x00',
                 'RX_TGID':      '\x00\x00\x00',
@@ -202,6 +452,7 @@ class routerSYSTEM(HBSYSTEM):
                 'RX_TIME':      time(),
                 'TX_TIME':      time(),
                 'RX_TYPE':      hb_const.HBPF_SLT_VTERM,
+                'TX_TYPE':      hb_const.HBPF_SLT_VTERM,
                 'RX_LC':        '\x00',
                 'TX_H_LC':      '\x00',
                 'TX_T_LC':      '\x00',
@@ -214,185 +465,277 @@ class routerSYSTEM(HBSYSTEM):
                 }
             }
 
-    def dmrd_received(self, _radio_id, _rf_src, _dst_id, _seq, _slot, _call_type, _frame_type, _dtype_vseq, _stream_id, _data):
+    def dmrd_received(self, _peer_id, _rf_src, _dst_id, _seq, _slot, _call_type, _frame_type, _dtype_vseq, _stream_id, _data):
         pkt_time = time()
         dmrpkt = _data[20:53]
         _bits = int_id(_data[15])
 
         if _call_type == 'group':
-            
-            # Check for ACL match, and return if the subscriber is not allowed
-            if allow_sub(_rf_src) == False:
-                self._logger.warning('(%s) Group Voice Packet ***REJECTED BY ACL*** From: %s, HBP Peer %s, Destination TGID %s', self._system, int_id(_rf_src), int_id(_radio_id), int_id(_dst_id))
-                return
-            
-            # Is this a new call stream?   
+
+            # Is this a new call stream?
             if (_stream_id != self.STATUS[_slot]['RX_STREAM_ID']):
                 if (self.STATUS[_slot]['RX_TYPE'] != hb_const.HBPF_SLT_VTERM) and (pkt_time < (self.STATUS[_slot]['RX_TIME'] + hb_const.STREAM_TO)) and (_rf_src != self.STATUS[_slot]['RX_RFS']):
-                    self._logger.warning('(%s) Packet received with STREAM ID: %s <FROM> SUB: %s REPEATER: %s <TO> TGID %s, SLOT %s collided with existing call', self._system, int_id(_stream_id), int_id(_rf_src), int_id(_radio_id), int_id(_dst_id), _slot)
+                    logger.warning('(%s) Packet received with STREAM ID: %s <FROM> SUB: %s PEER: %s <TO> TGID %s, SLOT %s collided with existing call', self._system, int_id(_stream_id), int_id(_rf_src), int_id(_peer_id), int_id(_dst_id), _slot)
                     return
-                
+
                 # This is a new call stream
-                self.STATUS['RX_START'] = pkt_time
-                self._logger.info('(%s) *CALL START* STREAM ID: %s SUB: %s (%s) REPEATER: %s (%s) TGID %s (%s), TS %s', \
-                        self._system, int_id(_stream_id), get_alias(_rf_src, subscriber_ids), int_id(_rf_src), get_alias(_radio_id, peer_ids), int_id(_radio_id), get_alias(_dst_id, talkgroup_ids), int_id(_dst_id), _slot)
-                
+                self.STATUS[_slot]['RX_START'] = pkt_time
+                logger.info('(%s) *CALL START* STREAM ID: %s SUB: %s (%s) PEER: %s (%s) TGID %s (%s), TS %s', \
+                        self._system, int_id(_stream_id), get_alias(_rf_src, subscriber_ids), int_id(_rf_src), get_alias(_peer_id, peer_ids), int_id(_peer_id), get_alias(_dst_id, talkgroup_ids), int_id(_dst_id), _slot)
+                if CONFIG['REPORTS']['REPORT']:
+                    self._report.send_bridgeEvent('GROUP VOICE,START,RX,{},{},{},{},{},{}'.format(self._system, int_id(_stream_id), int_id(_peer_id), int_id(_rf_src), _slot, int_id(_dst_id)))
+
                 # If we can, use the LC from the voice header as to keep all options intact
                 if _frame_type == hb_const.HBPF_DATA_SYNC and _dtype_vseq == hb_const.HBPF_SLT_VHEAD:
                     decoded = decode.voice_head_term(dmrpkt)
                     self.STATUS[_slot]['RX_LC'] = decoded['LC']
-                
+
                 # If we don't have a voice header then don't wait to decode it from the Embedded LC
                 # just make a new one from the HBP header. This is good enough, and it saves lots of time
                 else:
                     self.STATUS[_slot]['RX_LC'] = const.LC_OPT + _dst_id + _rf_src
 
-
             for _bridge in BRIDGES:
                 for _system in BRIDGES[_bridge]:
- 
+
                     if (_system['SYSTEM'] == self._system and _system['TGID'] == _dst_id and _system['TS'] == _slot and _system['ACTIVE'] == True):
-                        
+
                         for _target in BRIDGES[_bridge]:
                             if _target['SYSTEM'] != self._system:
-                                if _target['ACTIVE']:                             
+                                if _target['ACTIVE']:
                                     _target_status = systems[_target['SYSTEM']].STATUS
                                     _target_system = self._CONFIG['SYSTEMS'][_target['SYSTEM']]
-                                
-                                    # BEGIN CONTENTION HANDLING
-                                    #
-                                    # The rules for each of the 4 "ifs" below are listed here for readability. The Frame To Send is:
-                                    #   From a different group than last RX from this HBSystem, but it has been less than Group Hangtime
-                                    #   From a different group than last TX to this HBSystem, but it has been less than Group Hangtime
-                                    #   From the same group as the last RX from this HBSystem, but from a different subscriber, and it has been less than stream timeout
-                                    #   From the same group as the last TX to this HBSystem, but from a different subscriber, and it has been less than stream timeout
-                                    # The "continue" at the end of each means the next iteration of the for loop that tests for matching rules
-                                    #
-                                    if ((_target['TGID'] != _target_status[_target['TS']]['RX_TGID']) and ((pkt_time - _target_status[_target['TS']]['RX_TIME']) < _target_system['GROUP_HANGTIME'])):
-                                        if _frame_type == hb_const.HBPF_DATA_SYNC and _dtype_vseq == hb_const.HBPF_SLT_VHEAD and self.STATUS[_slot]['RX_STREAM_ID'] != _seq:
-                                            self._logger.info('(%s) Call not routed to TGID %s, target active or in group hangtime: HBSystem: %s, TS: %s, TGID: %s', self._system, int_id(_target['TGID']), _target['SYSTEM'], _target['TS'], int_id(_target_status[_target['TS']]['RX_TGID']))
-                                        continue
-                                    if ((_target['TGID'] != _target_status[_target['TS']]['TX_TGID']) and ((pkt_time - _target_status[_target['TS']]['TX_TIME']) < _target_system['GROUP_HANGTIME'])):
-                                        if _frame_type == hb_const.HBPF_DATA_SYNC and _dtype_vseq == hb_const.HBPF_SLT_VHEAD and self.STATUS[_slot]['RX_STREAM_ID'] != _seq:
-                                            self._logger.info('(%s) Call not routed to TGID%s, target in group hangtime: HBSystem: %s, TS: %s, TGID: %s', self._system, int_id(_target['TGID']), _target['SYSTEM'], _target['TS'], int_id(_target_status[_target['TS']]['TX_TGID']))
-                                        continue
-                                    if (_target['TGID'] == _target_status[_target['TS']]['RX_TGID']) and ((pkt_time - _target_status[_target['TS']]['RX_TIME']) < hb_const.STREAM_TO):
-                                        if _frame_type == hb_const.HBPF_DATA_SYNC and _dtype_vseq == hb_const.HBPF_SLT_VHEAD and self.STATUS[_slot]['RX_STREAM_ID'] != _seq:
-                                            self._logger.info('(%s) Call not routed to TGID%s, matching call already active on target: HBSystem: %s, TS: %s, TGID: %s', self._system, int_id(_target['TGID']), _target['SYSTEM'], _target['TS'], int_id(_target_status[_target['TS']]['RX_TGID']))
-                                        continue
-                                    if (_target['TGID'] == _target_status[_target['TS']]['TX_TGID']) and (_rf_src != _target_status[_target['TS']]['TX_RFS']) and ((pkt_time - _target_status[_target['TS']]['TX_TIME']) < hb_const.STREAM_TO):
-                                        if _frame_type == hb_const.HBPF_DATA_SYNC and _dtype_vseq == hb_const.HBPF_SLT_VHEAD and self.STATUS[_slot]['RX_STREAM_ID'] != _seq:
-                                            self._logger.info('(%s) Call not routed for subscriber %s, call route in progress on target: HBSystem: %s, TS: %s, TGID: %s, SUB: %s', self._system, int_id(_rf_src), _target['SYSTEM'], _target['TS'], int_id(_target_status[_target['TS']]['TX_TGID']), _target_status[_target['TS']]['TX_RFS'])
-                                        continue
-                                
-                                    # Set values for the contention handler to test next time there is a frame to forward
-                                    _target_status[_target['TS']]['TX_TIME'] = pkt_time
-                    
-                                    if (_stream_id != self.STATUS[_slot]['RX_STREAM_ID']) or (_target_status[_target['TS']]['TX_RFS'] != _rf_src) or (_target_status[_target['TS']]['TX_TGID'] != _target['TGID']):       
-                                        # Record the DST TGID and Stream ID
-                                        _target_status[_target['TS']]['TX_TGID'] = _target['TGID']
-                                        _target_status[_target['TS']]['TX_STREAM_ID'] = _stream_id
-                                        _target_status[_target['TS']]['TX_RFS'] = _rf_src
-                                        # Generate LCs (full and EMB) for the TX stream
-                                        dst_lc = self.STATUS[_slot]['RX_LC'][0:3] + _target['TGID'] + _rf_src
-                                        _target_status[_target['TS']]['TX_H_LC'] = bptc.encode_header_lc(dst_lc)
-                                        _target_status[_target['TS']]['TX_T_LC'] = bptc.encode_terminator_lc(dst_lc)
-                                        _target_status[_target['TS']]['TX_EMB_LC'] = bptc.encode_emblc(dst_lc)
-                                        self._logger.debug('(%s) Generating TX FULL and EMB LCs for destination: System: %s, TS: %s, TGID: %s', self._system, _target['SYSTEM'], _target['TS'], int_id(_target['TGID']))
-                                        self._logger.info('(%s) Conference Bridge: %s, Call Bridged to: System: %s TS: %s, TGID: %s', self._system, _bridge, _target['SYSTEM'], _target['TS'], int_id(_target['TGID']))
-                    
-                                    # Handle any necessary re-writes for the destination
-                                    if _system['TS'] != _target['TS']:
-                                        _tmp_bits = _bits ^ 1 << 7
+
+                                    if _target_system['MODE'] == 'OPENBRIDGE':
+                                        # Is this a new call stream on the target?
+                                        if (_stream_id not in _target_status):
+                                            # This is a new call stream on the target
+                                            _target_status[_stream_id] = {
+                                                'START':     pkt_time,
+                                                'CONTENTION':False,
+                                                'RFS':       _rf_src,
+                                                'TGID':      _dst_id,
+                                            }
+                                            # Generate LCs (full and EMB) for the TX stream
+                                            dst_lc = ''.join([self.STATUS[_slot]['RX_LC'][0:3], _target['TGID'], _rf_src])
+                                            _target_status[_stream_id]['H_LC'] = bptc.encode_header_lc(dst_lc)
+                                            _target_status[_stream_id]['T_LC'] = bptc.encode_terminator_lc(dst_lc)
+                                            _target_status[_stream_id]['EMB_LC'] = bptc.encode_emblc(dst_lc)
+                                            
+                                            logger.info('(%s) Conference Bridge: %s, Call Bridged to OBP System: %s TS: %s, TGID: %s', self._system, _bridge, _target['SYSTEM'], _target['TS'], int_id(_target['TGID']))
+                                            if CONFIG['REPORTS']['REPORT']:
+                                                systems[_target['SYSTEM']]._report.send_bridgeEvent('GROUP VOICE,START,TX,{},{},{},{},{},{}'.format(_target['SYSTEM'], int_id(_stream_id), int_id(_peer_id), int_id(_rf_src), _target['TS'], int_id(_target['TGID'])))
+
+                                        # Record the time of this packet so we can later identify a stale stream
+                                        _target_status[_stream_id]['LAST'] = pkt_time
+                                        # Clear the TS bit -- all OpenBridge streams are effectively on TS1
+                                        _tmp_bits = _bits & ~(1 << 7)
+
+                                        # Assemble transmit HBP packet header
+                                        _tmp_data = _data[:8] + _target['TGID'] + _data[11:15] + chr(_tmp_bits) + _data[16:20]
+
+                                        # MUST TEST FOR NEW STREAM AND IF SO, RE-WRITE THE LC FOR THE TARGET
+                                        # MUST RE-WRITE DESTINATION TGID IF DIFFERENT
+                                        # if _dst_id != rule['DST_GROUP']:
+                                        dmrbits = bitarray(endian='big')
+                                        dmrbits.frombytes(dmrpkt)
+                                        # Create a voice header packet (FULL LC)
+                                        if _frame_type == hb_const.HBPF_DATA_SYNC and _dtype_vseq == hb_const.HBPF_SLT_VHEAD:
+                                            dmrbits = _target_status[_stream_id]['H_LC'][0:98] + dmrbits[98:166] + _target_status[_stream_id]['H_LC'][98:197]
+                                        # Create a voice terminator packet (FULL LC)
+                                        elif _frame_type == hb_const.HBPF_DATA_SYNC and _dtype_vseq == hb_const.HBPF_SLT_VTERM:
+                                            dmrbits = _target_status[_stream_id]['T_LC'][0:98] + dmrbits[98:166] + _target_status[_stream_id]['T_LC'][98:197]
+                                            if CONFIG['REPORTS']['REPORT']:
+                                                call_duration = pkt_time - _target_status[_stream_id]['START']
+                                                systems[_target['SYSTEM']]._report.send_bridgeEvent('GROUP VOICE,END,TX,{},{},{},{},{},{},{:.2f}'.format(_target['SYSTEM'], int_id(_stream_id), int_id(_peer_id), int_id(_rf_src), _target['TS'], int_id(_target['TGID']), call_duration))
+                                        # Create a Burst B-E packet (Embedded LC)
+                                        elif _dtype_vseq in [1,2,3,4]:
+                                            dmrbits = dmrbits[0:116] + _target_status[_stream_id]['EMB_LC'][_dtype_vseq] + dmrbits[148:264]
+                                        dmrpkt = dmrbits.tobytes()
+                                        _tmp_data = _tmp_data + dmrpkt #+ _data[53:55]
+
                                     else:
-                                        _tmp_bits = _bits
-                    
-                                    # Assemble transmit HBP packet header
-                                    _tmp_data = _data[:8] + _target['TGID'] + _data[11:15] + chr(_tmp_bits) + _data[16:20]
-                    
-                                    # MUST TEST FOR NEW STREAM AND IF SO, RE-WRITE THE LC FOR THE TARGET
-                                    # MUST RE-WRITE DESTINATION TGID IF DIFFERENT
-                                    # if _dst_id != rule['DST_GROUP']:
-                                    dmrbits = bitarray(endian='big')
-                                    dmrbits.frombytes(dmrpkt)
-                                    # Create a voice header packet (FULL LC)
-                                    if _frame_type == hb_const.HBPF_DATA_SYNC and _dtype_vseq == hb_const.HBPF_SLT_VHEAD:
-                                        dmrbits = _target_status[_target['TS']]['TX_H_LC'][0:98] + dmrbits[98:166] + _target_status[_target['TS']]['TX_H_LC'][98:197]
-                                    # Create a voice terminator packet (FULL LC)
-                                    elif _frame_type == hb_const.HBPF_DATA_SYNC and _dtype_vseq == hb_const.HBPF_SLT_VTERM:
-                                        dmrbits = _target_status[_target['TS']]['TX_T_LC'][0:98] + dmrbits[98:166] + _target_status[_target['TS']]['TX_T_LC'][98:197]
-                                    # Create a Burst B-E packet (Embedded LC)
-                                    elif _dtype_vseq in [1,2,3,4]:
-                                        dmrbits = dmrbits[0:116] + _target_status[_target['TS']]['TX_EMB_LC'][_dtype_vseq] + dmrbits[148:264]
-                                    dmrpkt = dmrbits.tobytes()
-                                    _tmp_data = _tmp_data + dmrpkt + _data[53:55]
-                    
+                                        # BEGIN STANDARD CONTENTION HANDLING
+                                        #
+                                        # The rules for each of the 4 "ifs" below are listed here for readability. The Frame To Send is:
+                                        #   From a different group than last RX from this HBSystem, but it has been less than Group Hangtime
+                                        #   From a different group than last TX to this HBSystem, but it has been less than Group Hangtime
+                                        #   From the same group as the last RX from this HBSystem, but from a different subscriber, and it has been less than stream timeout
+                                        #   From the same group as the last TX to this HBSystem, but from a different subscriber, and it has been less than stream timeout
+                                        # The "continue" at the end of each means the next iteration of the for loop that tests for matching rules
+                                        #
+                                        if ((_target['TGID'] != _target_status[_target['TS']]['RX_TGID']) and ((pkt_time - _target_status[_target['TS']]['RX_TIME']) < _target_system['GROUP_HANGTIME'])):
+                                            if _frame_type == hb_const.HBPF_DATA_SYNC and _dtype_vseq == hb_const.HBPF_SLT_VHEAD and self.STATUS[_slot]['RX_STREAM_ID'] != _seq:
+                                                logger.info('(%s) Call not routed to TGID %s, target active or in group hangtime: HBSystem: %s, TS: %s, TGID: %s', self._system, int_id(_target['TGID']), _target['SYSTEM'], _target['TS'], int_id(_target_status[_target['TS']]['RX_TGID']))
+                                            continue
+                                        if ((_target['TGID'] != _target_status[_target['TS']]['TX_TGID']) and ((pkt_time - _target_status[_target['TS']]['TX_TIME']) < _target_system['GROUP_HANGTIME'])):
+                                            if _frame_type == hb_const.HBPF_DATA_SYNC and _dtype_vseq == hb_const.HBPF_SLT_VHEAD and self.STATUS[_slot]['RX_STREAM_ID'] != _seq:
+                                                logger.info('(%s) Call not routed to TGID%s, target in group hangtime: HBSystem: %s, TS: %s, TGID: %s', self._system, int_id(_target['TGID']), _target['SYSTEM'], _target['TS'], int_id(_target_status[_target['TS']]['TX_TGID']))
+                                            continue
+                                        if (_target['TGID'] == _target_status[_target['TS']]['RX_TGID']) and ((pkt_time - _target_status[_target['TS']]['RX_TIME']) < hb_const.STREAM_TO):
+                                            if _frame_type == hb_const.HBPF_DATA_SYNC and _dtype_vseq == hb_const.HBPF_SLT_VHEAD and self.STATUS[_slot]['RX_STREAM_ID'] != _seq:
+                                                logger.info('(%s) Call not routed to TGID%s, matching call already active on target: HBSystem: %s, TS: %s, TGID: %s', self._system, int_id(_target['TGID']), _target['SYSTEM'], _target['TS'], int_id(_target_status[_target['TS']]['RX_TGID']))
+                                            continue
+                                        if (_target['TGID'] == _target_status[_target['TS']]['TX_TGID']) and (_rf_src != _target_status[_target['TS']]['TX_RFS']) and ((pkt_time - _target_status[_target['TS']]['TX_TIME']) < hb_const.STREAM_TO):
+                                            if _frame_type == hb_const.HBPF_DATA_SYNC and _dtype_vseq == hb_const.HBPF_SLT_VHEAD and self.STATUS[_slot]['RX_STREAM_ID'] != _seq:
+                                                logger.info('(%s) Call not routed for subscriber %s, call route in progress on target: HBSystem: %s, TS: %s, TGID: %s, SUB: %s', self._system, int_id(_rf_src), _target['SYSTEM'], _target['TS'], int_id(_target_status[_target['TS']]['TX_TGID']), int_id(_target_status[_target['TS']]['TX_RFS']))
+                                            continue
+
+                                        # Is this a new call stream? 
+                                        if (_stream_id != self.STATUS[_slot]['RX_STREAM_ID']) or (_target_status[_target['TS']]['TX_RFS'] != _rf_src) or (_target_status[_target['TS']]['TX_TGID'] != _target['TGID']):
+                                             # Record the DST TGID and Stream ID
+                                             _target_status[_target['TS']]['TX_START'] = pkt_time
+                                             _target_status[_target['TS']]['TX_TGID'] = _target['TGID']
+                                             _target_status[_target['TS']]['TX_STREAM_ID'] = _stream_id
+                                             _target_status[_target['TS']]['TX_RFS'] = _rf_src
+                                             _target_status[_target['TS']]['TX_PEER'] = _peer_id
+                                             # Generate LCs (full and EMB) for the TX stream
+                                             dst_lc = self.STATUS[_slot]['RX_LC'][0:3] + _target['TGID'] + _rf_src
+                                             _target_status[_target['TS']]['TX_H_LC'] = bptc.encode_header_lc(dst_lc)
+                                             _target_status[_target['TS']]['TX_T_LC'] = bptc.encode_terminator_lc(dst_lc)
+                                             _target_status[_target['TS']]['TX_EMB_LC'] = bptc.encode_emblc(dst_lc)
+                                             logger.debug('(%s) Generating TX FULL and EMB LCs for HomeBrew destination: System: %s, TS: %s, TGID: %s', self._system, _target['SYSTEM'], _target['TS'], int_id(_target['TGID']))
+                                             logger.info('(%s) Conference Bridge: %s, Call Bridged to HBP System: %s TS: %s, TGID: %s', self._system, _bridge, _target['SYSTEM'], _target['TS'], int_id(_target['TGID']))
+                                             if CONFIG['REPORTS']['REPORT']:
+                                                systems[_target['SYSTEM']]._report.send_bridgeEvent('GROUP VOICE,START,TX,{},{},{},{},{},{}'.format(_target['SYSTEM'], int_id(_stream_id), int_id(_peer_id), int_id(_rf_src), _target['TS'], int_id(_target['TGID'])))
+
+                                        # Set other values for the contention handler to test next time there is a frame to forward
+                                        _target_status[_target['TS']]['TX_TIME'] = pkt_time
+                                        _target_status[_target['TS']]['TX_TYPE'] = _dtype_vseq
+
+                                        # Handle any necessary re-writes for the destination
+                                        if _system['TS'] != _target['TS']:
+                                            _tmp_bits = _bits ^ 1 << 7
+                                        else:
+                                            _tmp_bits = _bits
+
+                                        # Assemble transmit HBP packet header
+                                        _tmp_data = _data[:8] + _target['TGID'] + _data[11:15] + chr(_tmp_bits) + _data[16:20]
+
+                                        # MUST TEST FOR NEW STREAM AND IF SO, RE-WRITE THE LC FOR THE TARGET
+                                        # MUST RE-WRITE DESTINATION TGID IF DIFFERENT
+                                        # if _dst_id != rule['DST_GROUP']:
+                                        dmrbits = bitarray(endian='big')
+                                        dmrbits.frombytes(dmrpkt)
+                                        # Create a voice header packet (FULL LC)
+                                        if _frame_type == hb_const.HBPF_DATA_SYNC and _dtype_vseq == hb_const.HBPF_SLT_VHEAD:
+                                            dmrbits = _target_status[_target['TS']]['TX_H_LC'][0:98] + dmrbits[98:166] + _target_status[_target['TS']]['TX_H_LC'][98:197]
+                                        # Create a voice terminator packet (FULL LC)
+                                        elif _frame_type == hb_const.HBPF_DATA_SYNC and _dtype_vseq == hb_const.HBPF_SLT_VTERM:
+                                            dmrbits = _target_status[_target['TS']]['TX_T_LC'][0:98] + dmrbits[98:166] + _target_status[_target['TS']]['TX_T_LC'][98:197]
+                                            if CONFIG['REPORTS']['REPORT']:
+                                                call_duration = pkt_time - _target_status[_target['TS']]['TX_START']
+                                                systems[_target['SYSTEM']]._report.send_bridgeEvent('GROUP VOICE,END,TX,{},{},{},{},{},{},{:.2f}'.format(_target['SYSTEM'], int_id(_stream_id), int_id(_peer_id), int_id(_rf_src), _target['TS'], int_id(_target['TGID']), call_duration))
+                                        # Create a Burst B-E packet (Embedded LC)
+                                        elif _dtype_vseq in [1,2,3,4]:
+                                            dmrbits = dmrbits[0:116] + _target_status[_target['TS']]['TX_EMB_LC'][_dtype_vseq] + dmrbits[148:264]
+                                        dmrpkt = dmrbits.tobytes()
+                                        _tmp_data = _tmp_data + dmrpkt + _data[53:55]
+
                                     # Transmit the packet to the destination system
                                     systems[_target['SYSTEM']].send_system(_tmp_data)
-                                    #self._logger.debug('(%s) Packet routed by bridge: %s to system: %s TS: %s, TGID: %s', self._system, _bridge, _target['SYSTEM'], _target['TS'], int_id(_target['TGID']))
-            
-            
-            
+                                    #logger.debug('(%s) Packet routed by bridge: %s to system: %s TS: %s, TGID: %s', self._system, _bridge, _target['SYSTEM'], _target['TS'], int_id(_target['TGID']))
+
+
+
             # Final actions - Is this a voice terminator?
             if (_frame_type == hb_const.HBPF_DATA_SYNC) and (_dtype_vseq == hb_const.HBPF_SLT_VTERM) and (self.STATUS[_slot]['RX_TYPE'] != hb_const.HBPF_SLT_VTERM):
-                call_duration = pkt_time - self.STATUS['RX_START']
-                self._logger.info('(%s) *CALL END*   STREAM ID: %s SUB: %s (%s) REPEATER: %s (%s) TGID %s (%s), TS %s, Duration: %s', \
-                        self._system, int_id(_stream_id), get_alias(_rf_src, subscriber_ids), int_id(_rf_src), get_alias(_radio_id, peer_ids), int_id(_radio_id), get_alias(_dst_id, talkgroup_ids), int_id(_dst_id), _slot, call_duration)
-                
+                call_duration = pkt_time - self.STATUS[_slot]['RX_START']
+                logger.info('(%s) *CALL END*   STREAM ID: %s SUB: %s (%s) PEER: %s (%s) TGID %s (%s), TS %s, Duration: %s', \
+                        self._system, int_id(_stream_id), get_alias(_rf_src, subscriber_ids), int_id(_rf_src), get_alias(_peer_id, peer_ids), int_id(_peer_id), get_alias(_dst_id, talkgroup_ids), int_id(_dst_id), _slot, call_duration)
+                if CONFIG['REPORTS']['REPORT']:
+                   self._report.send_bridgeEvent('GROUP VOICE,END,RX,{},{},{},{},{},{},{:.2f}'.format(self._system, int_id(_stream_id), int_id(_peer_id), int_id(_rf_src), _slot, int_id(_dst_id), call_duration))
+
                 #
                 # Begin in-band signalling for call end. This has nothign to do with routing traffic directly.
                 #
-                
+
                 # Iterate the rules dictionary
-                
+
                 for _bridge in BRIDGES:
                     for _system in BRIDGES[_bridge]:
                         if _system['SYSTEM'] == self._system:
-            
+
                             # TGID matches a rule source, reset its timer
                             if _slot == _system['TS'] and _dst_id == _system['TGID'] and ((_system['TO_TYPE'] == 'ON' and (_system['ACTIVE'] == True)) or (_system['TO_TYPE'] == 'OFF' and _system['ACTIVE'] == False)):
                                 _system['TIMER'] = pkt_time + _system['TIMEOUT']
-                                self._logger.info('(%s) Transmission match for Bridge: %s. Reset timeout to %s', self._system, _bridge, _system['TIMER'])
-            
-                            # TGID matches an ACTIVATION trigger
-                            if _dst_id in _system['ON']:
-                                # Set the matching rule as ACTIVE
-                                _system['ACTIVE'] = True
-                                _system['TIMER'] = pkt_time + _system['TIMEOUT']
-                                self._logger.info('(%s) Bridge: %s, connection changed to state: %s', self._system, _bridge, _system['ACTIVE'])
-                        
-                            # TGID matches an DE-ACTIVATION trigger
-                            if _dst_id in _system['OFF']:
-                                # Set the matching rule as ACTIVE
-                                _system['ACTIVE'] = False
-                                self._logger.info('(%s) Bridge: %s, connection changed to state: %s', self._system, _bridge, _system['ACTIVE'])
+                                logger.info('(%s) Transmission match for Bridge: %s. Reset timeout to %s', self._system, _bridge, _system['TIMER'])
 
-            #                    
+                            # TGID matches an ACTIVATION trigger
+                            if (_dst_id in _system['ON'] or _dst_id in _system['RESET']) and _slot == _system['TS']:
+                                # Set the matching rule as ACTIVE
+                                if _dst_id in _system['ON']:
+                                    if _system['ACTIVE'] == False:
+                                        _system['ACTIVE'] = True
+                                        _system['TIMER'] = pkt_time + _system['TIMEOUT']
+                                        logger.info('(%s) Bridge: %s, connection changed to state: %s', self._system, _bridge, _system['ACTIVE'])
+                                        # Cancel the timer if we've enabled an "OFF" type timeout
+                                        if _system['TO_TYPE'] == 'OFF':
+                                            _system['TIMER'] = pkt_time
+                                            logger.info('(%s) Bridge: %s set to "OFF" with an on timer rule: timeout timer cancelled', self._system, _bridge)
+                                # Reset the timer for the rule
+                                if _system['ACTIVE'] == True and _system['TO_TYPE'] == 'ON':
+                                    _system['TIMER'] = pkt_time + _system['TIMEOUT']
+                                    logger.info('(%s) Bridge: %s, timeout timer reset to: %s', self._system, _bridge, _system['TIMER'] - pkt_time)
+
+                            # TGID matches an DE-ACTIVATION trigger
+                            if (_dst_id in _system['OFF']  or _dst_id in _system['RESET']) and _slot == _system['TS']:
+                                # Set the matching rule as ACTIVE
+                                if _dst_id in _system['OFF']:
+                                    if _system['ACTIVE'] == True:
+                                        _system['ACTIVE'] = False
+                                        logger.info('(%s) Bridge: %s, connection changed to state: %s', self._system, _bridge, _system['ACTIVE'])
+                                        # Cancel the timer if we've enabled an "ON" type timeout
+                                        if _system['TO_TYPE'] == 'ON':
+                                            _system['TIMER'] = pkt_time
+                                            logger.info('(%s) Bridge: %s set to ON with and "OFF" timer rule: timeout timer cancelled', self._system, _bridge)
+                                # Reset the timer for the rule
+                                if _system['ACTIVE'] == False and _system['TO_TYPE'] == 'OFF':
+                                    _system['TIMER'] = pkt_time + _system['TIMEOUT']
+                                    logger.info('(%s) Bridge: %s, timeout timer reset to: %s', self._system, _bridge, _system['TIMER'] - pkt_time)
+                                # Cancel the timer if we've enabled an "ON" type timeout
+                                if _system['ACTIVE'] == True and _system['TO_TYPE'] == 'ON' and _dst_group in _system['OFF']:
+                                    _system['TIMER'] = pkt_time
+                                    logger.info('(%s) Bridge: %s set to ON with and "OFF" timer rule: timeout timer cancelled', self._system, _bridge)
+
+            #
             # END IN-BAND SIGNALLING
             #
-                
-                
+
+
             # Mark status variables for use later
+            self.STATUS[_slot]['RX_PEER']      = _peer_id
             self.STATUS[_slot]['RX_SEQ']       = _seq
             self.STATUS[_slot]['RX_RFS']       = _rf_src
             self.STATUS[_slot]['RX_TYPE']      = _dtype_vseq
             self.STATUS[_slot]['RX_TGID']      = _dst_id
             self.STATUS[_slot]['RX_TIME']      = pkt_time
             self.STATUS[_slot]['RX_STREAM_ID'] = _stream_id
-                
+
+#
+# Socket-based reporting section
+#
+class confbridgeReportFactory(reportFactory):
+
+    def send_bridge(self):
+        serialized = pickle.dumps(BRIDGES, protocol=pickle.HIGHEST_PROTOCOL)
+        self.send_clients(REPORT_OPCODES['BRIDGE_SND']+serialized)
+
+    def send_bridgeEvent(self, _data):
+        self.send_clients(REPORT_OPCODES['BRDG_EVENT']+_data)
+
 
 #************************************************
 #      MAIN PROGRAM LOOP STARTS HERE
 #************************************************
 
 if __name__ == '__main__':
-    
+
     import argparse
     import sys
     import os
     import signal
-    from dmr_utils.utils import try_download, mk_id_dict
-    
+
     # Change the current directory to the location of the application
     os.chdir(os.path.dirname(os.path.realpath(sys.argv[0])))
 
@@ -408,63 +751,58 @@ if __name__ == '__main__':
 
     # Call the external routine to build the configuration dictionary
     CONFIG = hb_config.build_config(cli_args.CONFIG_FILE)
-    
+
     # Start the system logger
     if cli_args.LOG_LEVEL:
         CONFIG['LOGGER']['LOG_LEVEL'] = cli_args.LOG_LEVEL
     logger = hb_log.config_logging(CONFIG['LOGGER'])
+    logger.info('\n\nCopyright (c) 2013, 2014, 2015, 2016, 2018\n\tThe Founding Members of the K0USY Group. All rights reserved.\n')
     logger.debug('Logging system started, anything from here on gets logged')
-    
+
     # Set up the signal handler
     def sig_handler(_signal, _frame):
-        logger.info('SHUTDOWN: HBROUTER IS TERMINATING WITH SIGNAL %s', str(_signal))
-        hblink_handler(_signal, _frame, logger)
+        logger.info('SHUTDOWN: CONFBRIDGE IS TERMINATING WITH SIGNAL %s', str(_signal))
+        hblink_handler(_signal, _frame)
         logger.info('SHUTDOWN: ALL SYSTEM HANDLERS EXECUTED - STOPPING REACTOR')
         reactor.stop()
-        
+
     # Set signal handers so that we can gracefully exit if need be
-    for sig in [signal.SIGTERM, signal.SIGINT]:
+    for sig in [signal.SIGINT, signal.SIGTERM]:
         signal.signal(sig, sig_handler)
     
-    # ID ALIAS CREATION
-    # Download
-    if CONFIG['ALIASES']['TRY_DOWNLOAD'] == True:
-        # Try updating peer aliases file
-        result = try_download(CONFIG['ALIASES']['PATH'], CONFIG['ALIASES']['PEER_FILE'], CONFIG['ALIASES']['PEER_URL'], CONFIG['ALIASES']['STALE_TIME'])
-        logger.info(result)
-        # Try updating subscriber aliases file
-        result = try_download(CONFIG['ALIASES']['PATH'], CONFIG['ALIASES']['SUBSCRIBER_FILE'], CONFIG['ALIASES']['SUBSCRIBER_URL'], CONFIG['ALIASES']['STALE_TIME'])
-        logger.info(result)
-        
-    # Make Dictionaries
-    peer_ids = mk_id_dict(CONFIG['ALIASES']['PATH'], CONFIG['ALIASES']['PEER_FILE'])
-    if peer_ids:
-        logger.info('ID ALIAS MAPPER: peer_ids dictionary is available')
-        
-    subscriber_ids = mk_id_dict(CONFIG['ALIASES']['PATH'], CONFIG['ALIASES']['SUBSCRIBER_FILE'])
-    if subscriber_ids:
-        logger.info('ID ALIAS MAPPER: subscriber_ids dictionary is available')
-    
-    talkgroup_ids = mk_id_dict(CONFIG['ALIASES']['PATH'], CONFIG['ALIASES']['TGID_FILE'])
-    if talkgroup_ids:
-        logger.info('ID ALIAS MAPPER: talkgroup_ids dictionary is available')
-    
+    # Create the name-number mapping dictionaries
+    peer_ids, subscriber_ids, talkgroup_ids = mk_aliases(CONFIG)
+
     # Build the routing rules file
     BRIDGES = make_bridges('hb_confbridge_rules')
-    
-    # Build the Access Control List
-    ACL = build_acl('sub_acl')
-    
+
+    # INITIALIZE THE REPORTING LOOP
+    report_server = config_reports(CONFIG, confbridgeReportFactory)
+
     # HBlink instance creation
-    logger.info('HBlink \'hb_router.py\' (c) 2016 N0MJS & the K0USY Group - SYSTEM STARTING...')
+    logger.info('HBlink \'hb_confbridge.py\' -- SYSTEM STARTING...')
     for system in CONFIG['SYSTEMS']:
         if CONFIG['SYSTEMS'][system]['ENABLED']:
-            systems[system] = routerSYSTEM(system, CONFIG, logger)
+            if CONFIG['SYSTEMS'][system]['MODE'] == 'OPENBRIDGE':
+                systems[system] = routerOBP(system, CONFIG, report_server)
+            else:
+                systems[system] = routerHBP(system, CONFIG, report_server)
             reactor.listenUDP(CONFIG['SYSTEMS'][system]['PORT'], systems[system], interface=CONFIG['SYSTEMS'][system]['IP'])
             logger.debug('%s instance created: %s, %s', CONFIG['SYSTEMS'][system]['MODE'], system, systems[system])
-            
-    # Initialize the rule timer -- this if for user activated stuff
-    rule_timer = task.LoopingCall(rule_timer_loop)
-    rule_timer.start(60)
 
-    reactor.run()
+    def loopingErrHandle(failure):
+        logger.error('STOPPING REACTOR TO AVOID MEMORY LEAK: Unhandled error in timed loop.\n %s', failure)
+        reactor.stop()
+
+    # Initialize the rule timer -- this if for user activated stuff
+    rule_timer_task = task.LoopingCall(rule_timer_loop)
+    rule_timer = rule_timer_task.start(60)
+    rule_timer.addErrback(loopingErrHandle)
+
+    # Initialize the stream trimmer
+    stream_trimmer_task = task.LoopingCall(stream_trimmer_loop)
+    stream_trimmer = stream_trimmer_task.start(5)
+    stream_trimmer.addErrback(loopingErrHandle)
+    
+
+    reactor.run()

hb_confbridge_rules-SAMPLE.py

@@ -25,21 +25,23 @@ configuration file.
         a good value for documentation!
     * TIMOUT is a value in minutes for the timout timer. No, I won't make it 'seconds', so don't
         ask. Timers are performance "expense".
-
+    * RESET is a list of Talkgroup IDs that, in addition to the ON and OFF lists will cause a running
+        timer to be reset. This is useful   if you are using different TGIDs for voice traffic than
+        triggering. If you are not, there is NO NEED to use this feature.
 '''
 
 BRIDGES = {
     'WORLDWIDE': [
-            {'SYSTEM': 'MASTER-1',    'TS': 1, 'TGID': 1,    'ACTIVE': True, 'TIMEOUT': 2, 'TO_TYPE': 'ON',  'ON': [2,], 'OFF': [9,10]},
-            {'SYSTEM': 'CLIENT-1',    'TS': 1, 'TGID': 3100, 'ACTIVE': True, 'TIMEOUT': 2, 'TO_TYPE': 'ON',  'ON': [2,], 'OFF': [9,10]},
+            {'SYSTEM': 'MASTER-1',    'TS': 1, 'TGID': 1,    'ACTIVE': True, 'TIMEOUT': 2, 'TO_TYPE': 'ON',  'ON': [2,], 'OFF': [9,10], 'RESET': []},
+            {'SYSTEM': 'CLIENT-1',    'TS': 1, 'TGID': 3100, 'ACTIVE': True, 'TIMEOUT': 2, 'TO_TYPE': 'ON',  'ON': [2,], 'OFF': [9,10], 'RESET': []},
         ],
     'ENGLISH': [
-            {'SYSTEM': 'MASTER-1',    'TS': 1, 'TGID': 13,   'ACTIVE': True, 'TIMEOUT': 2, 'TO_TYPE': 'NONE', 'ON': [3,], 'OFF': [8,10]},
-            {'SYSTEM': 'CLIENT-2',    'TS': 1, 'TGID': 13,   'ACTIVE': True, 'TIMEOUT': 2, 'TO_TYPE': 'NONE', 'ON': [3,], 'OFF': [8,10]},
+            {'SYSTEM': 'MASTER-1',    'TS': 1, 'TGID': 13,   'ACTIVE': True, 'TIMEOUT': 2, 'TO_TYPE': 'NONE', 'ON': [3,], 'OFF': [8,10], 'RESET': []},
+            {'SYSTEM': 'CLIENT-2',    'TS': 1, 'TGID': 13,   'ACTIVE': True, 'TIMEOUT': 2, 'TO_TYPE': 'NONE', 'ON': [3,], 'OFF': [8,10], 'RESET': []},
         ],
     'STATEWIDE': [
-            {'SYSTEM': 'MASTER-1',    'TS': 2, 'TGID': 3129, 'ACTIVE': True, 'TIMEOUT': 2, 'TO_TYPE': 'NONE', 'ON': [4,], 'OFF': [7,10]},
-            {'SYSTEM': 'CLIENT-2',    'TS': 2, 'TGID': 3129, 'ACTIVE': True, 'TIMEOUT': 2, 'TO_TYPE': 'NONE', 'ON': [4,], 'OFF': [7,10]},
+            {'SYSTEM': 'MASTER-1',    'TS': 2, 'TGID': 3129, 'ACTIVE': True, 'TIMEOUT': 2, 'TO_TYPE': 'NONE', 'ON': [4,], 'OFF': [7,10], 'RESET': []},
+            {'SYSTEM': 'CLIENT-2',    'TS': 2, 'TGID': 3129, 'ACTIVE': True, 'TIMEOUT': 2, 'TO_TYPE': 'NONE', 'ON': [4,], 'OFF': [7,10], 'RESET': []},
         ]
 }
 

hb_config.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 #
 ###############################################################################
-#   Copyright (C) 2016  Cortney T. Buffington, N0MJS <n0mjs@me.com>
+#   Copyright (C) 2016-2018 Cortney T. Buffington, N0MJS <n0mjs@me.com>
 #
 #   This program is free software; you can redistribute it and/or modify
 #   it under the terms of the GNU General Public License as published by
@@ -28,17 +28,73 @@ change.
 
 import ConfigParser
 import sys
+import hb_const as const
 
 from socket import gethostbyname 
 
 # Does anybody read this stuff? There's a PEP somewhere that says I should do this.
 __author__     = 'Cortney T. Buffington, N0MJS'
-__copyright__  = 'Copyright (c) 2016 Cortney T. Buffington, N0MJS and the K0USY Group'
+__copyright__  = 'Copyright (c) 2016-2018 Cortney T. Buffington, N0MJS and the K0USY Group'
 __credits__    = 'Colin Durbridge, G4EML, Steve Zingman, N4IRS; Mike Zingman, N4IRR; Jonathan Naylor, G4KLX; Hans Barthen, DL5DI; Torsten Shultze, DG1HT'
 __license__    = 'GNU GPLv3'
 __maintainer__ = 'Cort Buffington, N0MJS'
 __email__      = 'n0mjs@me.com'
 
+# Processing of ALS goes here. It's separated from the acl_build function because this
+# code is hblink config-file format specific, and acl_build is abstracted
+def process_acls(_config):
+    # Global registration ACL
+    _config['GLOBAL']['REG_ACL'] = acl_build(_config['GLOBAL']['REG_ACL'], const.PEER_MAX)
+
+    # Global subscriber and TGID ACLs
+    for acl in ['SUB_ACL', 'TG1_ACL', 'TG2_ACL']:
+        _config['GLOBAL'][acl] = acl_build(_config['GLOBAL'][acl], const.ID_MAX)
+
+    # System level ACLs
+    for system in _config['SYSTEMS']:
+        # Registration ACLs (which make no sense for peer systems)
+        if _config['SYSTEMS'][system]['MODE'] == 'MASTER':
+            _config['SYSTEMS'][system]['REG_ACL'] = acl_build(_config['SYSTEMS'][system]['REG_ACL'], const.PEER_MAX)
+
+        # Subscriber and TGID ACLs (valid for all system types)
+        for acl in ['SUB_ACL', 'TG1_ACL', 'TG2_ACL']:
+            _config['SYSTEMS'][system][acl] = acl_build(_config['SYSTEMS'][system][acl], const.ID_MAX)
+
+# Create an access control list that is programatically useable from human readable:
+# ORIGINAL:  'DENY:1-5,3120101,3120124'
+# PROCESSED: (False, set([(1, 5), (3120124, 3120124), (3120101, 3120101)]))
+def acl_build(_acl, _max):
+    if not _acl:
+        return(True, set((const.ID_MIN, _max)))
+
+    acl = set()
+    sections = _acl.split(':')
+
+    if sections[0] == 'PERMIT':
+        action = True
+    else:
+        action = False
+
+    for entry in sections[1].split(','):
+        if entry == 'ALL':
+            acl.add((const.ID_MIN, _max))
+            break
+
+        elif '-' in entry:
+            start,end = entry.split('-')
+            start,end = int(start), int(end)
+            if (const.ID_MIN <= start <= _max) or (const.ID_MIN <= end <= _max):
+                acl.add((start, end))
+            else:
+                sys.exit('ACL CREATION ERROR, VALUE OUT OF RANGE (} - {})IN RANGE-BASED ENTRY: {}'.format(const.ID_MIN, _max, entry))
+        else:
+            id = int(entry)
+            if (const.ID_MIN <= id <= _max):
+                acl.add((id, id))
+            else:
+                 sys.exit('ACL CREATION ERROR, VALUE OUT OF RANGE ({} - {}) IN SINGLE ID ENTRY: {}'.format(const.ID_MIN, _max, entry))
+
+    return (action, acl)
 
 def build_config(_config_file):
     config = ConfigParser.ConfigParser()
@@ -48,9 +104,9 @@ def build_config(_config_file):
 
     CONFIG = {}
     CONFIG['GLOBAL'] = {}
+    CONFIG['REPORTS'] = {}
     CONFIG['LOGGER'] = {}
     CONFIG['ALIASES'] = {}
-    CONFIG['AMBE'] = {}
     CONFIG['SYSTEMS'] = {}
 
     try:
@@ -59,7 +115,20 @@ def build_config(_config_file):
                 CONFIG['GLOBAL'].update({
                     'PATH': config.get(section, 'PATH'),
                     'PING_TIME': config.getint(section, 'PING_TIME'),
-                    'MAX_MISSED': config.getint(section, 'MAX_MISSED')
+                    'MAX_MISSED': config.getint(section, 'MAX_MISSED'),
+                    'USE_ACL': config.get(section, 'USE_ACL'),
+                    'REG_ACL': config.get(section, 'REG_ACL'),
+                    'SUB_ACL': config.get(section, 'SUB_ACL'),
+                    'TG1_ACL': config.get(section, 'TGID_TS1_ACL'),
+                    'TG2_ACL': config.get(section, 'TGID_TS2_ACL')
+                })
+
+            elif section == 'REPORTS':
+                CONFIG['REPORTS'].update({
+                    'REPORT': config.getboolean(section, 'REPORT'),
+                    'REPORT_INTERVAL': config.getint(section, 'REPORT_INTERVAL'),
+                    'REPORT_PORT': config.getint(section, 'REPORT_PORT'),
+                    'REPORT_CLIENTS': config.get(section, 'REPORT_CLIENTS').split(',')
                 })
 
             elif section == 'LOGGER':
@@ -82,20 +151,16 @@ def build_config(_config_file):
                     'STALE_TIME': config.getint(section, 'STALE_DAYS') * 86400,
                 })
 
-            elif section == 'AMBE':
-                CONFIG['AMBE'].update({
-                    'EXPORT_IP': gethostbyname(config.get(section, 'EXPORT_IP')),
-                    'EXPORT_PORT': config.getint(section, 'EXPORT_PORT'),
-                })
-
             elif config.getboolean(section, 'ENABLED'):
-                if config.get(section, 'MODE') == 'CLIENT':
+                if config.get(section, 'MODE') == 'PEER':
                     CONFIG['SYSTEMS'].update({section: {
                         'MODE': config.get(section, 'MODE'),
                         'ENABLED': config.getboolean(section, 'ENABLED'),
-                        'EXPORT_AMBE': config.getboolean(section, 'EXPORT_AMBE'),
+                        'LOOSE': config.getboolean(section, 'LOOSE'),
+                        'SOCK_ADDR': (gethostbyname(config.get(section, 'IP')), config.getint(section, 'PORT')),
                         'IP': gethostbyname(config.get(section, 'IP')),
                         'PORT': config.getint(section, 'PORT'),
+                        'MASTER_SOCKADDR': (gethostbyname(config.get(section, 'MASTER_IP')), config.getint(section, 'MASTER_PORT')),
                         'MASTER_IP': gethostbyname(config.get(section, 'MASTER_IP')),
                         'MASTER_PORT': config.getint(section, 'MASTER_PORT'),
                         'PASSPHRASE': config.get(section, 'PASSPHRASE'),
@@ -115,12 +180,18 @@ def build_config(_config_file):
                         'SOFTWARE_ID': config.get(section, 'SOFTWARE_ID').ljust(40)[:40],
                         'PACKAGE_ID': config.get(section, 'PACKAGE_ID').ljust(40)[:40],
                         'GROUP_HANGTIME': config.getint(section, 'GROUP_HANGTIME'),
-                        'OPTIONS': config.get(section, 'OPTIONS')
+                        'OPTIONS': config.get(section, 'OPTIONS'),
+                        'USE_ACL': config.getboolean(section, 'USE_ACL'),
+                        'SUB_ACL': config.get(section, 'SUB_ACL'),
+                        'TG1_ACL': config.get(section, 'TGID_TS1_ACL'),
+                        'TG2_ACL': config.get(section, 'TGID_TS2_ACL')
                     }})
                     CONFIG['SYSTEMS'][section].update({'STATS': {
                         'CONNECTION': 'NO',             # NO, RTPL_SENT, AUTHENTICATED, CONFIG-SENT, YES 
+                        'CONNECTED': None,
                         'PINGS_SENT': 0,
                         'PINGS_ACKD': 0,
+                        'NUM_OUTSTANDING': 0,
                         'PING_OUTSTANDING': False,
                         'LAST_PING_TX_TIME': 0,
                         'LAST_PING_ACK_TIME': 0,
@@ -131,24 +202,44 @@ def build_config(_config_file):
                         'MODE': config.get(section, 'MODE'),
                         'ENABLED': config.getboolean(section, 'ENABLED'),
                         'REPEAT': config.getboolean(section, 'REPEAT'),
-                        'EXPORT_AMBE': config.getboolean(section, 'EXPORT_AMBE'),
+                        'MAX_PEERS': config.getint(section, 'MAX_PEERS'),
                         'IP': gethostbyname(config.get(section, 'IP')),
                         'PORT': config.getint(section, 'PORT'),
                         'PASSPHRASE': config.get(section, 'PASSPHRASE'),
-                        'GROUP_HANGTIME': config.getint(section, 'GROUP_HANGTIME')
+                        'GROUP_HANGTIME': config.getint(section, 'GROUP_HANGTIME'),
+                        'USE_ACL': config.getboolean(section, 'USE_ACL'),
+                        'REG_ACL': config.get(section, 'REG_ACL'),
+                        'SUB_ACL': config.get(section, 'SUB_ACL'),
+                        'TG1_ACL': config.get(section, 'TGID_TS1_ACL'),
+                        'TG2_ACL': config.get(section, 'TGID_TS2_ACL')
                     }})
-                    CONFIG['SYSTEMS'][section].update({'CLIENTS': {}})
+                    CONFIG['SYSTEMS'][section].update({'PEERS': {}})
+                    
+                elif config.get(section, 'MODE') == 'OPENBRIDGE':
+                    CONFIG['SYSTEMS'].update({section: {
+                        'MODE': config.get(section, 'MODE'),
+                        'ENABLED': config.getboolean(section, 'ENABLED'),
+                        'NETWORK_ID': hex(int(config.get(section, 'NETWORK_ID')))[2:].rjust(8,'0').decode('hex'),
+                        'IP': gethostbyname(config.get(section, 'IP')),
+                        'PORT': config.getint(section, 'PORT'),
+                        'PASSPHRASE': config.get(section, 'PASSPHRASE').ljust(20,'\x00')[:20],
+                        'TARGET_SOCK': (gethostbyname(config.get(section, 'TARGET_IP')), config.getint(section, 'TARGET_PORT')),
+                        'TARGET_IP': gethostbyname(config.get(section, 'TARGET_IP')),
+                        'TARGET_PORT': config.getint(section, 'TARGET_PORT'),
+                        'USE_ACL': config.getboolean(section, 'USE_ACL'),
+                        'SUB_ACL': config.get(section, 'SUB_ACL'),
+                        'TG1_ACL': config.get(section, 'TGID_ACL'),
+                        'TG2_ACL': 'PERMIT:ALL'
+                    }})
+                    
     
     except ConfigParser.Error, err:
-	    print "Cannot parse configuration file. %s" %err
-            sys.exit('Could not parse configuration file, exiting...')
+        sys.exit('Error processing configuration file -- {}'.format(err))
         
+    process_acls(CONFIG)
+    
     return CONFIG
 
-
-
-
-
 # Used to run this file direclty and print the config,
 # which might be useful for debugging
 if __name__ == '__main__':
@@ -156,6 +247,7 @@ if __name__ == '__main__':
     import os
     import argparse
     from pprint import pprint
+    from dmr_utils.utils import int_id
     
     # Change the current directory to the location of the application
     os.chdir(os.path.dirname(os.path.realpath(sys.argv[0])))
@@ -170,5 +262,14 @@ if __name__ == '__main__':
     if not cli_args.CONFIG_FILE:
         cli_args.CONFIG_FILE = os.path.dirname(os.path.abspath(__file__))+'/hblink.cfg'
     
+    CONFIG = build_config(cli_args.CONFIG_FILE)
+    pprint(CONFIG)
     
-    pprint(build_config(cli_args.CONFIG_FILE))
+    def acl_check(_id, _acl):
+        id = int_id(_id)
+        for entry in _acl[1]:
+            if entry[0] <= id <= entry[1]:
+                return _acl[0]
+        return not _acl[0]
+        
+    print acl_check('\x00\x01\x37', CONFIG['GLOBAL']['TG1_ACL'])

hb_const.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 #
 ###############################################################################
-#   Copyright (C) 2016  Cortney T. Buffington, N0MJS <n0mjs@me.com>
+#   Copyright (C) 2016-2018  Cortney T. Buffington, N0MJS <n0mjs@me.com>
 #
 #   This program is free software; you can redistribute it and/or modify
 #   it under the terms of the GNU General Public License as published by
@@ -33,6 +33,11 @@ __license__    = 'GNU GPLv3'
 __maintainer__ = 'Cort Buffington, N0MJS'
 __email__      = 'n0mjs@me.com'
 
+
+# DMR Related constants
+ID_MIN = 1
+ID_MAX = 16776415
+
 # Timers
 STREAM_TO = .360
 
@@ -41,4 +46,10 @@ HBPF_VOICE      = 0x0
 HBPF_VOICE_SYNC = 0x1
 HBPF_DATA_SYNC  = 0x2
 HBPF_SLT_VHEAD  = 0x1
-HBPF_SLT_VTERM  = 0x2
+HBPF_SLT_VTERM  = 0x2
+
+# Higheset peer ID permitted by HBP
+PEER_MAX = 4294967295
+
+# Use if late entry
+LC_OPT = '\x00\x00\x20'

hb_log.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 #
 ###############################################################################
-#   Copyright (C) 2016  Cortney T. Buffington, N0MJS <n0mjs@me.com>
+#   Copyright (C) 2016-2018  Cortney T. Buffington, N0MJS <n0mjs@me.com>
 #
 #   This program is free software; you can redistribute it and/or modify
 #   it under the terms of the GNU General Public License as published by
@@ -29,7 +29,7 @@ from logging.config import dictConfig
 
 # Does anybody read this stuff? There's a PEP somewhere that says I should do this.
 __author__     = 'Cortney T. Buffington, N0MJS'
-__copyright__  = 'Copyright (c) 2016 Cortney T. Buffington, N0MJS and the K0USY Group'
+__copyright__  = 'Copyright (c) 2016-2018 Cortney T. Buffington, N0MJS and the K0USY Group'
 __credits__    = 'Colin Durbridge, G4EML, Steve Zingman, N4IRS; Mike Zingman, N4IRR; Jonathan Naylor, G4KLX; Hans Barthen, DL5DI; Torsten Shultze, DG1HT'
 __license__    = 'GNU GPLv3'
 __maintainer__ = 'Cort Buffington, N0MJS'
@@ -83,13 +83,11 @@ def config_logging(_logger):
                 'formatter': 'syslog',
             }
         },
-        'loggers': {
-            _logger['LOG_NAME']: {
-                'handlers': _logger['LOG_HANDLERS'].split(','),
-                'level': _logger['LOG_LEVEL'],
-                'propagate': True,
-            }
-        }
+        'root': {
+            'handlers': _logger['LOG_HANDLERS'].split(','),
+            'level': _logger['LOG_LEVEL'],
+            'propagate': True,
+        },
     })
 
     return logging.getLogger(_logger['LOG_NAME'])

hb_parrot.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 #
 ###############################################################################
-#   Copyright (C) 2016  Cortney T. Buffington, N0MJS <n0mjs@me.com> (and Mike Zingman N4IRR)
+#   Copyright (C) 2016-2018  Cortney T. Buffington, N0MJS <n0mjs@me.com> (and Mike Zingman N4IRR)
 #
 #   This program is free software; you can redistribute it and/or modify
 #   it under the terms of the GNU General Public License as published by
@@ -30,18 +30,23 @@ from time import time, sleep
 from importlib import import_module
 
 # Twisted is pretty important, so I keep it separate
-from twisted.internet.protocol import DatagramProtocol
-from twisted.internet import reactor
-from twisted.internet import task
+from twisted.internet.protocol import Factory, Protocol
+from twisted.protocols.basic import NetstringReceiver
+from twisted.internet import reactor, task
 
 # Things we import from the main hblink module
-from hblink import HBSYSTEM, systems, int_id, hblink_handler
+from hblink import HBSYSTEM, systems, hblink_handler, reportFactory, REPORT_OPCODES, config_reports, mk_aliases
 from dmr_utils.utils import hex_str_3, int_id, get_alias
 from dmr_utils import decode, bptc, const
 import hb_config
 import hb_log
 import hb_const
 
+# The module needs logging logging, but handlers, etc. are controlled by the parent
+import logging
+logger = logging.getLogger(__name__)
+
+
 # Does anybody read this stuff? There's a PEP somewhere that says I should do this.
 __author__     = 'Cortney T. Buffington, N0MJS and Mike Zingman, N4IRR'
 __copyright__  = 'Copyright (c) 2016 Cortney T. Buffington, N0MJS and the K0USY Group'
@@ -54,10 +59,10 @@ __status__     = 'pre-alpha'
 # Module gobal varaibles
 
 class parrot(HBSYSTEM):
-    
-    def __init__(self, _name, _config, _logger):
-        HBSYSTEM.__init__(self, _name, _config, _logger)
-        
+
+    def __init__(self, _name, _config, _report):
+        HBSYSTEM.__init__(self, _name, _config, _report)
+
         # Status information for the system, TS1 & TS2
         # 1 & 2 are "timeslot"
         # In TX_EMB_LC, 2-5 are burst B-E
@@ -109,39 +114,38 @@ class parrot(HBSYSTEM):
         }
         self.CALL_DATA = []
 
-    def dmrd_received(self, _radio_id, _rf_src, _dst_id, _seq, _slot, _call_type, _frame_type, _dtype_vseq, _stream_id, _data):
+    def dmrd_received(self, _peer_id, _rf_src, _dst_id, _seq, _slot, _call_type, _frame_type, _dtype_vseq, _stream_id, _data):
         pkt_time = time()
         dmrpkt = _data[20:53]
         _bits = int_id(_data[15])
-        
         if _call_type == 'group':
-            
+
             # Is this is a new call stream?
             if (_stream_id != self.STATUS[_slot]['RX_STREAM_ID']):
                 self.STATUS['RX_START'] = pkt_time
-                self._logger.info('(%s) *CALL START* STREAM ID: %s SUB: %s (%s) REPEATER: %s (%s) TGID %s (%s), TS %s', \
-                                  self._system, int_id(_stream_id), get_alias(_rf_src, subscriber_ids), int_id(_rf_src), get_alias(_radio_id, peer_ids), int_id(_radio_id), get_alias(_dst_id, talkgroup_ids), int_id(_dst_id), _slot)
-        
-            
+                logger.info('(%s) *CALL START* STREAM ID: %s SUB: %s (%s) REPEATER: %s (%s) TGID %s (%s), TS %s', \
+                                  self._system, int_id(_stream_id), get_alias(_rf_src, subscriber_ids), int_id(_rf_src), get_alias(_peer_id, peer_ids), int_id(_peer_id), get_alias(_dst_id, talkgroup_ids), int_id(_dst_id), _slot)
+
+
             # Final actions - Is this a voice terminator?
             if (_frame_type == hb_const.HBPF_DATA_SYNC) and (_dtype_vseq == hb_const.HBPF_SLT_VTERM) and (self.STATUS[_slot]['RX_TYPE'] != hb_const.HBPF_SLT_VTERM):
                 call_duration = pkt_time - self.STATUS['RX_START']
-                self._logger.info('(%s) *CALL END*   STREAM ID: %s SUB: %s (%s) REPEATER: %s (%s) TGID %s (%s), TS %s, Duration: %s', \
-                                  self._system, int_id(_stream_id), get_alias(_rf_src, subscriber_ids), int_id(_rf_src), get_alias(_radio_id, peer_ids), int_id(_radio_id), get_alias(_dst_id, talkgroup_ids), int_id(_dst_id), _slot, call_duration)
+                logger.info('(%s) *CALL END*   STREAM ID: %s SUB: %s (%s) REPEATER: %s (%s) TGID %s (%s), TS %s, Duration: %s', \
+                                  self._system, int_id(_stream_id), get_alias(_rf_src, subscriber_ids), int_id(_rf_src), get_alias(_peer_id, peer_ids), int_id(_peer_id), get_alias(_dst_id, talkgroup_ids), int_id(_dst_id), _slot, call_duration)
                 self.CALL_DATA.append(_data)
                 sleep(2)
                 logger.info('(%s) Playing back transmission from subscriber: %s', self._system, int_id(_rf_src))
                 for i in self.CALL_DATA:
-                    self.send_clients(i)
+                    self.send_system(i)
                     sleep(0.06)
                 self.CALL_DATA = []
-            
+
             else:
                 if not self.CALL_DATA:
                     logger.info('(%s) Receiving transmission to be played back from subscriber: %s', self._system, int_id(_rf_src))
                 self.CALL_DATA.append(_data)
-            
-            
+
+
             # Mark status variables for use later
             self.STATUS[_slot]['RX_RFS']       = _rf_src
             self.STATUS[_slot]['RX_TYPE']      = _dtype_vseq
@@ -182,12 +186,13 @@ if __name__ == '__main__':
     if cli_args.LOG_LEVEL:
         CONFIG['LOGGER']['LOG_LEVEL'] = cli_args.LOG_LEVEL
     logger = hb_log.config_logging(CONFIG['LOGGER'])
+    logger.info('\n\nCopyright (c) 2013, 2014, 2015, 2016, 2018\n\tThe Founding Members of the K0USY Group. All rights reserved.\n')
     logger.debug('Logging system started, anything from here on gets logged')
     
     # Set up the signal handler
     def sig_handler(_signal, _frame):
         logger.info('SHUTDOWN: HBROUTER IS TERMINATING WITH SIGNAL %s', str(_signal))
-        hblink_handler(_signal, _frame, logger)
+        hblink_handler(_signal, _frame)
         logger.info('SHUTDOWN: ALL SYSTEM HANDLERS EXECUTED - STOPPING REACTOR')
         reactor.stop()
         
@@ -205,25 +210,21 @@ if __name__ == '__main__':
         result = try_download(CONFIG['ALIASES']['PATH'], CONFIG['ALIASES']['SUBSCRIBER_FILE'], CONFIG['ALIASES']['SUBSCRIBER_URL'], CONFIG['ALIASES']['STALE_TIME'])
         logger.info(result)
         
-    # Make Dictionaries
-    peer_ids = mk_id_dict(CONFIG['ALIASES']['PATH'], CONFIG['ALIASES']['PEER_FILE'])
-    if peer_ids:
-        logger.info('ID ALIAS MAPPER: peer_ids dictionary is available')
-        
-    subscriber_ids = mk_id_dict(CONFIG['ALIASES']['PATH'], CONFIG['ALIASES']['SUBSCRIBER_FILE'])
-    if subscriber_ids:
-        logger.info('ID ALIAS MAPPER: subscriber_ids dictionary is available')
-    
-    talkgroup_ids = mk_id_dict(CONFIG['ALIASES']['PATH'], CONFIG['ALIASES']['TGID_FILE'])
-    if talkgroup_ids:
-        logger.info('ID ALIAS MAPPER: talkgroup_ids dictionary is available')
+    # Create the name-number mapping dictionaries
+    peer_ids, subscriber_ids, talkgroup_ids = mk_aliases(CONFIG)
         
+    # INITIALIZE THE REPORTING LOOP
+    report_server = config_reports(CONFIG, reportFactory)    
     
     # HBlink instance creation
-    logger.info('HBlink \'hb_parrot.py\' (c) 2016 N0MJS & the K0USY Group - SYSTEM STARTING...')
+    logger.info('HBlink \'hb_parrot.py\' (c) 2017 Mike Zingman, N4IRR -- SYSTEM STARTING...')
     for system in CONFIG['SYSTEMS']:
         if CONFIG['SYSTEMS'][system]['ENABLED']:
-            systems[system] = parrot(system, CONFIG, logger)
+            if CONFIG['SYSTEMS'][system]['MODE'] == 'OPENBRIDGE':
+                logger.critical('%s FATAL: Instance is mode \'OPENBRIDGE\', \n\t\t...Which would be tragic for parrot, since it carries multiple call\n\t\tstreams simultaneously. hb_parrot.py onlyl works with MMDVM-based systems', system)
+                sys.exit('hb_parrot.py cannot function with systems that are not MMDVM devices. System {} is configured as an OPENBRIDGE'.format(system))
+            else:
+                systems[system] = parrot(system, CONFIG, report_server)
             reactor.listenUDP(CONFIG['SYSTEMS'][system]['PORT'], systems[system], interface=CONFIG['SYSTEMS'][system]['IP'])
             logger.debug('%s instance created: %s, %s', CONFIG['SYSTEMS'][system]['MODE'], system, systems[system])
 

hblink-SAMPLE.cfg

@@ -1,19 +1,77 @@
 # PROGRAM-WIDE PARAMETERS GO HERE
 # PATH - working path for files, leave it alone unless you NEED to change it
-# PING_TIME - the interval that clients will ping the master, and re-try registraion
+# PING_TIME - the interval that peers will ping the master, and re-try registraion
 #           - how often the Master maintenance loop runs
 # MAX_MISSED - how many pings are missed before we give up and re-register
-#           - number of times the master maintenance loop runs before de-registering a client
+#           - number of times the master maintenance loop runs before de-registering a peer
+#
+# ACLs:
+#
+# Access Control Lists are a very powerful tool for administering your system.
+# But they consume packet processing time. Disable them if you are not using them.
+# But be aware that, as of now, the configuration stanzas still need the ACL
+# sections configured even if you're not using them.
+#
+# REGISTRATION ACLS ARE ALWAYS USED, ONLY SUBSCRIBER AND TGID MAY BE DISABLED!!!
+#
+# The 'action' May be PERMIT|DENY
+# Each entry may be a single radio id, or a hypenated range (e.g. 1-2999)
+# Format:
+# 	ACL = 'action:id|start-end|,id|start-end,....'
+#		--for example--
+#	SUB_ACL: DENY:1,1000-2000,4500-60000,17
+#
+# ACL Types:
+# 	REG_ACL: peer radio IDs for registration (only used on HBP master systems)
+# 	SUB_ACL: subscriber IDs for end-users
+# 	TGID_TS1_ACL: destination talkgroup IDs on Timeslot 1
+# 	TGID_TS2_ACL: destination talkgroup IDs on Timeslot 2
+#
+# ACLs may be repeated for individual systems if needed for granularity
+# Global ACLs will be processed BEFORE the system level ACLs
+# Packets will be matched against all ACLs, GLOBAL first. If a packet 'passes'
+# All elements, processing continues. Packets are discarded at the first
+# negative match, or 'reject' from an ACL element.
+#
+# If you do not wish to use ACLs, set them to 'PERMIT:ALL'
+# TGID_TS1_ACL in the global stanza is used for OPENBRIDGE systems, since all
+# traffic is passed as TS 1 between OpenBridges
 [GLOBAL]
 PATH: ./
 PING_TIME: 5
 MAX_MISSED: 3
+USE_ACL: True
+REG_ACL: PERMIT:ALL
+SUB_ACL: DENY:1
+TGID_TS1_ACL: PERMIT:ALL
+TGID_TS2_ACL: PERMIT:ALL
+
+
+# NOT YET WORKING: NETWORK REPORTING CONFIGURATION
+#   Enabling "REPORT" will configure a socket-based reporting
+#   system that will send the configuration and other items
+#   to a another process (local or remote) that may process
+#   the information for some useful purpose, like a web dashboard.
+#
+#   REPORT - True to enable, False to disable
+#   REPORT_INTERVAL - Seconds between reports
+#   REPORT_PORT - TCP port to listen on if "REPORT_NETWORKS" = NETWORK
+#   REPORT_CLIENTS - comma separated list of IPs you will allow clients
+#       to connect on. Entering a * will allow all.
+#
+# ****FOR NOW MUST BE TRUE - USE THE LOOPBACK IF YOU DON'T USE THIS!!!****
+[REPORTS]
+REPORT: True
+REPORT_INTERVAL: 60
+REPORT_PORT: 4321
+REPORT_CLIENTS: 127.0.0.1
+
 
 # SYSTEM LOGGER CONFIGURAITON
 #   This allows the logger to be configured without chaning the individual
 #   python logger stuff. LOG_FILE should be a complete path/filename for *your*
 #   system -- use /dev/null for non-file handlers.
-#   LOG_HANDERLS may be any of the following, please, no spaces in the
+#   LOG_HANDLERS may be any of the following, please, no spaces in the
 #   list if you use several:
 #       null
 #       console
@@ -40,46 +98,88 @@ LOG_NAME: HBlink
 [ALIASES]
 TRY_DOWNLOAD: True
 PATH: ./
-PEER_FILE: peer_ids.csv
-SUBSCRIBER_FILE: subscriber_ids.csv
-TGID_FILE: talkgroup_ids.csv
-PEER_URL: http://www.dmr-marc.net/cgi-bin/trbo-database/datadump.cgi?table=repeaters&format=csv&header=0
-SUBSCRIBER_URL: http://www.dmr-marc.net/cgi-bin/trbo-database/datadump.cgi?table=users&format=csv&header=0
+PEER_FILE: peer_ids.json
+SUBSCRIBER_FILE: subscriber_ids.json
+TGID_FILE: talkgroup_ids.json
+PEER_URL: https://www.radioid.net/static/rptrs.json
+SUBSCRIBER_URL: https://www.radioid.net/static/users.json
 STALE_DAYS: 7
 
-# EXPORT AMBE DATA
-# This is for exporting AMBE audio frames to an an "external" process for
-# decoding or other nefarious actions.
-[AMBE]
-EXPORT_IP: 127.0.0.1
-EXPORT_PORT: 1234
+# OPENBRIDGE INSTANCES - DUPLICATE SECTION FOR MULTIPLE CONNECTIONS
+# OpenBridge is a protocol originall created by DMR+ for connection between an
+# IPSC2 server and Brandmeister. It has been implemented here at the suggestion
+# of the Brandmeister team as a way to legitimately connect HBlink to the
+# Brandemiester network.
+# It is recommended to name the system the ID of the Brandmeister server that
+# it connects to, but is not necessary. TARGET_IP and TARGET_PORT are of the
+# Brandmeister or IPSC2 server you are connecting to. PASSPHRASE is the password
+# that must be agreed upon between you and the operator of the server you are
+# connecting to. NETWORK_ID is a number in the format of a DMR Radio ID that
+# will be sent to the other server to identify this connection.
+# other parameters follow the other system types.
+#
+# ACLs:
+# OpenBridge does not 'register', so registration ACL is meaningless.
+# OpenBridge passes all traffic on TS1, so there is only 1 TGID ACL.
+# Otherwise ACLs work as described in the global stanza
+[OBP-1]
+MODE: OPENBRIDGE
+ENABLED: True
+IP:
+PORT: 62035
+NETWORK_ID: 3129100
+PASSPHRASE: password
+TARGET_IP: 1.2.3.4
+TARGET_PORT: 62035
+USE_ACL: True
+SUB_ACL: DENY:1
+TGID_ACL: PERMIT:ALL
 
 # MASTER INSTANCES - DUPLICATE SECTION FOR MULTIPLE MASTERS
 # HomeBrew Protocol Master instances go here.
 # IP may be left blank if there's one interface on your system.
 # Port should be the port you want this master to listen on. It must be unique
 # and unused by anything else.
-# Repeat - if True, the master repeats traffic to clients, False, it does nothing.
+# Repeat - if True, the master repeats traffic to peers, False, it does nothing.
+#
+# MAX_PEERS -- maximun number of peers that may be connect to this master
+# at any given time. This is very handy if you're allowing hotspots to
+# connect, or using a limited computer like a Raspberry Pi.
+#
+# ACLs:
+# See comments in the GLOBAL stanza
 [MASTER-1]
 MODE: MASTER
 ENABLED: True
 REPEAT: True
+MAX_PEERS: 10
 EXPORT_AMBE: False
 IP:
 PORT: 54000
 PASSPHRASE: s3cr37w0rd
 GROUP_HANGTIME: 5
+USE_ACL: True
+REG_ACL: DENY:1
+SUB_ACL: DENY:1
+TGID_TS1_ACL: PERMIT:ALL
+TGID_TS2_ACL: PERMIT:ALL
 
-# CLIENT INSTANCES - DUPLICATE SECTION FOR MULTIPLE CLIENTS
+# PEER INSTANCES - DUPLICATE SECTION FOR MULTIPLE PEERS
 # There are a LOT of errors in the HB Protocol specifications on this one!
 # MOST of these items are just strings and will be properly dealt with by the program
 # The TX & RX Frequencies are 9-digit numbers, and are the frequency in Hz.
 # Latitude is an 8-digit unsigned floating point number.
 # Longitude is a 9-digit signed floating point number.
 # Height is in meters
+# Setting Loose to True relaxes the validation on packets received from the master.
+# This will allow HBlink to connect to a non-compliant system such as XLXD, DMR+ etc.
+#
+# ACLs:
+# See comments in the GLOBAL stanza
 [REPEATER-1]
-MODE: CLIENT
+MODE: PEER
 ENABLED: True
+LOOSE: False
 EXPORT_AMBE: False
 IP: 
 PORT: 54001
@@ -99,7 +199,11 @@ HEIGHT: 75
 LOCATION: Anywhere, USA
 DESCRIPTION: This is a cool repeater
 URL: www.w1abc.org
-SOFTWARE_ID: HBlink
-PACKAGE_ID: v0.1
+SOFTWARE_ID: 20170620
+PACKAGE_ID: MMDVM_HBlink
 GROUP_HANGTIME: 5
-OPTIONS: 
+OPTIONS:
+USE_ACL: True
+SUB_ACL: DENY:1
+TGID_TS1_ACL: PERMIT:ALL
+TGID_TS2_ACL: PERMIT:ALL

install.sh

@@ -0,0 +1,6 @@
+#! /bin/bash
+
+# Install the required support programs
+apt-get install python-pip -y
+pip install -r requirements.txt
+

reporting_const.py

@@ -0,0 +1,30 @@
+###############################################################################
+#   Copyright (C) 2018  Cortney T. Buffington, N0MJS <n0mjs@me.com>
+#
+#   This program is free software; you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation; either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with this program; if not, write to the Free Software Foundation,
+#   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+###############################################################################
+
+# Opcodes for the network-based reporting protocol
+
+REPORT_OPCODES = {
+    'CONFIG_REQ': '\x00',
+    'CONFIG_SND': '\x01',
+    'BRIDGE_REQ': '\x02',
+    'BRIDGE_SND': '\x03',
+    'CONFIG_UPD': '\x04',
+    'BRIDGE_UPD': '\x05',
+    'LINK_EVENT': '\x06',
+    'BRDG_EVENT': '\x07',
+    }

retired/hb_router.py

@@ -38,12 +38,12 @@ from time import time
 from importlib import import_module
 
 # Twisted is pretty important, so I keep it separate
-from twisted.internet.protocol import DatagramProtocol
-from twisted.internet import reactor
-from twisted.internet import task
+from twisted.internet.protocol import Factory, Protocol
+from twisted.protocols.basic import NetstringReceiver
+from twisted.internet import reactor, task
 
 # Things we import from the main hblink module
-from hblink import HBSYSTEM, systems, int_id, hblink_handler
+from hblink import HBSYSTEM, systems, hblink_handler, reportFactory, REPORT_OPCODES, config_reports
 from dmr_utils.utils import hex_str_3, int_id, get_alias
 from dmr_utils import decode, bptc, const
 import hb_config
@@ -101,10 +101,25 @@ def make_rules(_hb_routing_rules):
 # are not yet implemented.
 def build_acl(_sub_acl):
     try:
+        logger.info('ACL file found, importing entries. This will take about 1.5 seconds per 1 million IDs')
         acl_file = import_module(_sub_acl)
-        for i, e in enumerate(acl_file.ACL):
-            acl_file.ACL[i] = hex_str_3(acl_file.ACL[i])
-        logger.info('ACL file found and ACL entries imported')
+        sections = acl_file.ACL.split(':')
+        ACL_ACTION = sections[0]
+        entries_str = sections[1]
+        ACL = set()
+        
+        for entry in entries_str.split(','):
+            if '-' in entry:
+                start,end = entry.split('-')
+                start,end = int(start), int(end)
+                for id in range(start, end+1):
+                    ACL.add(hex_str_3(id))
+            else:
+                id = int(entry)
+                ACL.add(hex_str_3(id))
+        
+        logger.info('ACL loaded: action "{}" for {:,} radio IDs'.format(ACL_ACTION, len(ACL)))
+    
     except ImportError:
         logger.info('ACL file not found or invalid - all subscriber IDs are valid')
         ACL_ACTION = 'NONE'
@@ -112,13 +127,13 @@ def build_acl(_sub_acl):
     # Depending on which type of ACL is used (PERMIT, DENY... or there isn't one)
     # define a differnet function to be used to check the ACL
     global allow_sub
-    if acl_file.ACL_ACTION == 'PERMIT':
+    if ACL_ACTION == 'PERMIT':
         def allow_sub(_sub):
             if _sub in ACL:
                 return True
             else:
                 return False
-    elif acl_file.ACL_ACTION == 'DENY':
+    elif ACL_ACTION == 'DENY':
         def allow_sub(_sub):
             if _sub not in ACL:
                 return True
@@ -128,7 +143,7 @@ def build_acl(_sub_acl):
         def allow_sub(_sub):
             return True
     
-    return acl_file.ACL
+    return ACL
 
 
 # Run this every minute for rule timer updates
@@ -159,8 +174,8 @@ def rule_timer_loop():
 
 class routerSYSTEM(HBSYSTEM):
     
-    def __init__(self, _name, _config, _logger):
-        HBSYSTEM.__init__(self, _name, _config, _logger)
+    def __init__(self, _name, _config, _logger, _report):
+        HBSYSTEM.__init__(self, _name, _config, _logger, _report)
         
         # Status information for the system, TS1 & TS2
         # 1 & 2 are "timeslot"
@@ -212,7 +227,7 @@ class routerSYSTEM(HBSYSTEM):
                 }
             }
 
-    def dmrd_received(self, _radio_id, _rf_src, _dst_id, _seq, _slot, _call_type, _frame_type, _dtype_vseq, _stream_id, _data):
+    def dmrd_received(self, _peer_id, _rf_src, _dst_id, _seq, _slot, _call_type, _frame_type, _dtype_vseq, _stream_id, _data):
         pkt_time = time()
         dmrpkt = _data[20:53]
         _bits = int_id(_data[15])
@@ -221,19 +236,19 @@ class routerSYSTEM(HBSYSTEM):
             
             # Check for ACL match, and return if the subscriber is not allowed
             if allow_sub(_rf_src) == False:
-                self._logger.warning('(%s) Group Voice Packet ***REJECTED BY ACL*** From: %s, HBP Peer %s, Destination TGID %s', self._system, int_id(_rf_src), int_id(_radio_id), int_id(_dst_id))
+                self._logger.warning('(%s) Group Voice Packet ***REJECTED BY ACL*** From: %s, HBP Peer %s, Destination TGID %s', self._system, int_id(_rf_src), int_id(_peer_id), int_id(_dst_id))
                 return
             
             # Is this a new call stream?   
             if (_stream_id != self.STATUS[_slot]['RX_STREAM_ID']):
                 if (self.STATUS[_slot]['RX_TYPE'] != hb_const.HBPF_SLT_VTERM) and (pkt_time < (self.STATUS[_slot]['RX_TIME'] + hb_const.STREAM_TO)) and (_rf_src != self.STATUS[_slot]['RX_RFS']):
-                    self._logger.warning('(%s) Packet received with STREAM ID: %s <FROM> SUB: %s REPEATER: %s <TO> TGID %s, SLOT %s collided with existing call', self._system, int_id(_stream_id), int_id(_rf_src), int_id(_radio_id), int_id(_dst_id), _slot)
+                    self._logger.warning('(%s) Packet received with STREAM ID: %s <FROM> SUB: %s PEER: %s <TO> TGID %s, SLOT %s collided with existing call', self._system, int_id(_stream_id), int_id(_rf_src), int_id(_peer_id), int_id(_dst_id), _slot)
                     return
                 
                 # This is a new call stream
                 self.STATUS['RX_START'] = pkt_time
-                self._logger.info('(%s) *CALL START* STREAM ID: %s SUB: %s (%s) REPEATER: %s (%s) TGID %s (%s), TS %s', \
-                        self._system, int_id(_stream_id), get_alias(_rf_src, subscriber_ids), int_id(_rf_src), get_alias(_radio_id, peer_ids), int_id(_radio_id), get_alias(_dst_id, talkgroup_ids), int_id(_dst_id), _slot)
+                self._logger.info('(%s) *CALL START* STREAM ID: %s SUB: %s (%s) PEER: %s (%s) TGID %s (%s), TS %s', \
+                        self._system, int_id(_stream_id), get_alias(_rf_src, subscriber_ids), int_id(_rf_src), get_alias(_peer_id, peer_ids), int_id(_peer_id), get_alias(_dst_id, talkgroup_ids), int_id(_dst_id), _slot)
                 
                 # If we can, use the LC from the voice header as to keep all options intact
                 if _frame_type == hb_const.HBPF_DATA_SYNC and _dtype_vseq == hb_const.HBPF_SLT_VHEAD:
@@ -330,8 +345,8 @@ class routerSYSTEM(HBSYSTEM):
             # Final actions - Is this a voice terminator?
             if (_frame_type == hb_const.HBPF_DATA_SYNC) and (_dtype_vseq == hb_const.HBPF_SLT_VTERM) and (self.STATUS[_slot]['RX_TYPE'] != hb_const.HBPF_SLT_VTERM):
                 call_duration = pkt_time - self.STATUS['RX_START']
-                self._logger.info('(%s) *CALL END*   STREAM ID: %s SUB: %s (%s) REPEATER: %s (%s) TGID %s (%s), TS %s, Duration: %s', \
-                        self._system, int_id(_stream_id), get_alias(_rf_src, subscriber_ids), int_id(_rf_src), get_alias(_radio_id, peer_ids), int_id(_radio_id), get_alias(_dst_id, talkgroup_ids), int_id(_dst_id), _slot, call_duration)
+                self._logger.info('(%s) *CALL END*   STREAM ID: %s SUB: %s (%s) PEER: %s (%s) TGID %s (%s), TS %s, Duration: %s', \
+                        self._system, int_id(_stream_id), get_alias(_rf_src, subscriber_ids), int_id(_rf_src), get_alias(_peer_id, peer_ids), int_id(_peer_id), get_alias(_dst_id, talkgroup_ids), int_id(_dst_id), _slot, call_duration)
                 
                 #
                 # Begin in-band signalling for call end. This has nothign to do with routing traffic directly.
@@ -465,11 +480,14 @@ if __name__ == '__main__':
     # Build the Access Control List
     ACL = build_acl('sub_acl')
     
+    # INITIALIZE THE REPORTING LOOP
+    report_server = config_reports(CONFIG, logger, reportFactory)    
+    
     # HBlink instance creation
     logger.info('HBlink \'hb_router.py\' (c) 2016 N0MJS & the K0USY Group - SYSTEM STARTING...')
     for system in CONFIG['SYSTEMS']:
         if CONFIG['SYSTEMS'][system]['ENABLED']:
-            systems[system] = routerSYSTEM(system, CONFIG, logger)
+            systems[system] = routerSYSTEM(system, CONFIG, logger, report_server)
             reactor.listenUDP(CONFIG['SYSTEMS'][system]['PORT'], systems[system], interface=CONFIG['SYSTEMS'][system]['IP'])
             logger.debug('%s instance created: %s, %s', CONFIG['SYSTEMS'][system]['MODE'], system, systems[system])
             

sub_acl.py

@@ -1,12 +0,0 @@
-'''
-This is the Access Control List (ACL) file for limiting call
-routing/bridging in various hblink.py-based applications. It
-is a VERY simple format. The action may be to PERMIT or DENY
-and the ACL itself is a list of subscriber IDs that may be
-permitted or denied.
-'''
-
-ACL_ACTION = "DENY"  # May be PERMIT|DENY
-ACL = [
-    1,2,3,4,5,6,7,8,9,10,100
-    ]

systemd/README.md

@@ -0,0 +1,24 @@
+Copy required service file into /lib/systemd/system
+To make the network-online.target available (required by HB service files)
+systemctl enable systemd-networkd-wait-online.service
+
+
+Example HB confbridge service
+
+Enable the service at boot
+systemctl enable hb_confbridge.service
+
+Check the status of the service
+systemctl status hb_confbridge.service
+
+Start the service if stopped
+systemctl start hb_confbridge.service
+
+Restart the service
+systemctl restart hb_confbridge.service
+
+Stop the service if running
+systemctl stop hb_confbridge.service
+
+Disable starting the service at boot
+systemctl disable hb_confbridge.service

systemd/hb_bridge_all.service

@@ -0,0 +1,21 @@
+[Unit]
+Description=HB bridge all Service
+# Description=Place this file in /lib/systemd/system
+# Description=N4IRS 04/20/2018
+
+# To make the network-online.target available
+# systemctl enable systemd-networkd-wait-online.service
+
+After=network-online.target syslog.target
+Wants=network-online.target
+
+[Service]
+StandardOutput=null
+WorkingDirectory=/opt/HBlink
+RestartSec=3
+ExecStart=/usr/bin/python /opt/HBlink/hb_bridge_all.py
+Restart=on-abort
+
+[Install]
+WantedBy=multi-user.target
+

systemd/hb_confbridge.service

@@ -0,0 +1,21 @@
+[Unit]
+Description=HB bridge conference bridge Service
+# Description=Place this file in /lib/systemd/system
+# Description=N4IRS 04/20/2018
+
+# To make the network-online.target available
+# systemctl enable systemd-networkd-wait-online.service
+
+After=network-online.target syslog.target
+Wants=network-online.target
+
+[Service]
+StandardOutput=null
+WorkingDirectory=/opt/HBlink
+RestartSec=3
+ExecStart=/usr/bin/python /opt/HBlink/hb_confbridge.py
+Restart=on-abort
+
+[Install]
+WantedBy=multi-user.target
+

talkgroup_ids.csv

@@ -1 +0,0 @@
-1,Worldwide
2,Local
3,North America
9,BrandMeister
13,Worldwide English
310,TAC 310
3100,DCI Bridge 2
3160,DCI 1
3169,Midwest
3172,Northeast
3174,Southeast
3112,Flordia
3120,Kansas Statewide
3125,Massachussetts
3129,Missouri
31201,BYRG KC
3777215,DCI Comm 1
9998,Echo Server