Update to json

Update hblink.cfg to use ham-digital DMR ID CSVs

.gitignore

@@ -9,10 +9,6 @@ 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

HB_Bridge.cfg

@@ -0,0 +1,15 @@
+################################################
+# HB_Bridge configuration file.
+################################################
+
+[DEFAULTS]
+gateway = 127.0.0.1                             # IP address of Partner Application (IPSC_Bridge, Analog_Bridge)
+fromGatewayPort = 31103                         # Port HB_Bridge is listening on for data  (HB_Bridge <--- Partner)
+toGatewayPort = 31100                           # Port Partner is listening on for data  (HB_Bridge ---> Partner)
+
+[RULES]
+# Name = Old TG, New TG, New Slot
+TG_SE = 3174, 3174, 2
+TG_NA = 3,3,1
+TG_ATL = 8,8,1
+TG_WW = 1,1,1

HB_Bridge.py

@@ -0,0 +1,247 @@
+#!/usr/bin/env python
+#
+###############################################################################
+#   Copyright (C) 2017 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
+#   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
+###############################################################################
+
+'''
+'''
+
+from __future__ import print_function
+
+# Python modules we need
+import sys
+from bitarray import bitarray
+from bitstring import BitArray
+from bitstring import BitString
+import struct
+from time import time, sleep
+from importlib import import_module
+from binascii import b2a_hex as ahex
+from random import randint
+import sys, socket, ConfigParser, thread, traceback
+from threading import Lock
+from time import time, sleep, clock, localtime, strftime
+
+# 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
+
+# Things we import from the main hblink module
+from hblink import HBSYSTEM, systems, int_id, hblink_handler
+from dmr_utils.utils import hex_str_3, hex_str_4, int_id, get_alias
+from dmr_utils import decode, bptc, const, golay, qr
+import hb_config
+import hb_log
+import hb_const
+from dmr_utils import ambe_utils
+from dmr_utils.ambe_bridge import AMBE_HB
+
+# Does anybody read this stuff? There's a PEP somewhere that says I should do this.
+__author__     = 'Mike Zingman, N4IRR and Cortney T. Buffington, N0MJS'
+__copyright__  = 'Copyright (c) 2017 Mike Zingman N4IRR'
+__credits__    = 'Cortney T. Buffington, N0MJS; Colin Durbridge, G4EML, Steve Zingman, N4IRS; Jonathan Naylor, G4KLX; Hans Barthen, DL5DI; Torsten Shultze, DG1HT'
+__license__    = 'GNU GPLv3'
+__maintainer__ = 'Cort Buffington, N0MJS'
+__email__      = 'n0mjs@me.com'
+__status__     = 'pre-alpha'
+__version__    = '20170620'
+
+mutex = Lock()  # Used to synchronize Peer I/O in different threads
+
+class TRANSLATE:
+    def __init__(self, config_file):
+        self.translate = {}
+        self.load_config(config_file)
+        pass
+    def add_rule( self, tg, export_rule):
+        self.translate[str(tg)] = export_rule
+        #print(int_id(tg), export_rule)
+    def delete_rule(self, tg):
+        if str(tg) in self.translate:
+            del self.translate[str(tg)]
+    def find_rule(self, tg, slot):
+        if str(tg) in self.translate:
+            return self.translate[str(tg)]
+        return (tg, slot)
+    def load_config(self, config_file):
+        print('load config file', config_file)
+        pass
+
+# translation structure.  IMPORT_TO translates foreign (TG,TS) to local.  EXPORT_AS translates local (TG,TS) to foreign values
+translate = TRANSLATE('config.file')
+
+class HB_BRIDGE(HBSYSTEM):
+    
+    def __init__(self, _name, _config, _logger):
+        HBSYSTEM.__init__(self, _name, _config, _logger)
+
+
+        self._ambeRxPort = 31003        # Port to listen on for AMBE frames to transmit to all peers
+        self._gateway = "127.0.0.1"     # IP address of Analog_Bridge app
+        self._gateway_port = 31000      # Port Analog_Bridge is listening on for AMBE frames to decode
+
+        self.load_configuration(cli_args.BRIDGE_CONFIG_FILE)
+
+        self.hb_ambe = AMBE_HB(self, _name, _config, _logger, self._ambeRxPort)
+        self._sock = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
+
+    def get_globals(self):
+        return (subscriber_ids, talkgroup_ids, peer_ids)
+
+    def get_repeater_id(self, import_id):
+        if self._config['MODE'] == 'CLIENT':    # only clients have radio_id defined, masters do not
+            return self._config['RADIO_ID']
+        return import_id
+
+    # Load configuration from file
+    def load_configuration( self, _file_name ):
+        config = ConfigParser.ConfigParser()
+        if not config.read(_file_name):
+            sys.exit('Configuration file \''+_file_name+'\' is not a valid configuration file! Exiting...')
+        try:
+            for section in config.sections():
+                if section == 'DEFAULTS':
+                    self._ambeRxPort = int(config.get(section, 'fromGatewayPort').split(None)[0])           # Port to listen on for AMBE frames to transmit to all peers
+                    self._gateway = config.get(section, 'gateway').split(None)[0]                           # IP address of Analog_Bridge app
+                    self._gateway_port = int(config.get(section, 'toGatewayPort').split(None)[0])           # Port Analog_Bridge is listening on for AMBE frames to decode
+                if section == 'RULES':
+                    for rule in config.items(section):
+                        _old_tg, _new_tg, _new_slot = rule[1].split(',')
+                        translate.add_rule(hex_str_3(int(_old_tg)), (hex_str_3(int(_new_tg)), int(_new_slot)))
+
+        except ConfigParser.Error, err:
+            traceback.print_exc()
+            sys.exit('Could not parse configuration file, ' + _file_name + ', exiting...')
+
+
+    # HBLink callback with DMR data from perr/master.  Send this data to any partner listening
+    def dmrd_received(self, _radio_id, _rf_src, _dst_id, _seq, _slot, _call_type, _frame_type, _dtype_vseq, _stream_id, _data):
+        _dst_id, _slot = translate.find_rule(_dst_id,_slot)
+        _tx_slot = self.hb_ambe.tx[_slot]
+        _seq = ord(_data[4])
+        _tx_slot.frame_count += 1
+        if (_stream_id != _tx_slot.stream_id):
+            self.hb_ambe.begin_call(_slot, _rf_src, _dst_id, _radio_id, _tx_slot.cc, _seq, _stream_id)
+            _tx_slot.lastSeq = _seq
+        if (_frame_type == hb_const.HBPF_DATA_SYNC) and (_dtype_vseq == hb_const.HBPF_SLT_VTERM) and (_tx_slot.type != hb_const.HBPF_SLT_VTERM):
+            self.hb_ambe.end_call(_tx_slot)
+        if (int_id(_data[15]) & 0x20) == 0:
+            _dmr_frame = BitArray('0x'+ahex(_data[20:]))
+            _ambe = _dmr_frame[0:108] + _dmr_frame[156:264]
+            self.hb_ambe.export_voice(_tx_slot, _seq, _ambe.tobytes())
+        else:
+            _tx_slot.lastSeq = _seq
+
+    # The methods below are overridden becuse the launchUDP thread can also wite to a master or client async and confuse the master
+    # A lock is used to synchronize the two threads so that the resource is protected
+    def send_master(self, _packet):
+        mutex.acquire()
+        HBSYSTEM.send_master(self, _packet)
+        mutex.release()
+    
+    def send_clients(self, _packet):
+        mutex.acquire()
+        HBSYSTEM.send_clients(self, _packet)
+        mutex.release()
+
+############################################################################################################
+#      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])))
+
+    # CLI argument parser - handles picking up the config file from the command line, and sending a "help" message
+    # Added the capability to define a custom bridge config file, multiple bridges are needed when doing things like Analog_Bridge
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-c', '--config', action='store', dest='CONFIG_FILE', help='/full/path/to/config.file (default hblink.cfg)')
+    parser.add_argument('-l', '--logging', action='store', dest='LOG_LEVEL', help='Override config file logging level.')
+    parser.add_argument('-b','--bridge_config', action='store', dest='BRIDGE_CONFIG_FILE', help='/full/path/to/bridgeconfig.cfg (default HB_Bridge.cfg)')
+    cli_args = parser.parse_args()
+
+    # Ensure we have a path for the config file, if one wasn't specified, then use the default (top of file)
+    if not cli_args.CONFIG_FILE:
+        cli_args.CONFIG_FILE = os.path.dirname(os.path.abspath(__file__))+'/hblink.cfg'
+
+    # Ensure we have a path for the bridge config file, if one wasn't specified, then use the default (top of file)
+    if not cli_args.BRIDGE_CONFIG_FILE:
+        cli_args.BRIDGE_CONFIG_FILE = os.path.dirname(os.path.abspath(__file__))+'/HB_Bridge.cfg'
+
+    # 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.debug('Logging system started, anything from here on gets logged')
+    
+    # Set up the signal handler
+    def sig_handler(_signal, _frame):
+        logger.info('SHUTDOWN: HB_Bridge IS TERMINATING WITH SIGNAL %s', str(_signal))
+        hblink_handler(_signal, _frame, logger)
+        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')
+        
+    
+    # HBlink instance creation
+    logger.info('HBlink \'HB_Bridge.py\' (c) 2017 Mike Zingman N4IRR, N0MJS - SYSTEM STARTING...')
+    logger.info('Version %s', __version__)
+    for system in CONFIG['SYSTEMS']:
+        if CONFIG['SYSTEMS'][system]['ENABLED']:
+            systems[system] = HB_BRIDGE(system, CONFIG, logger)
+            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()

README.md

@@ -1,7 +1,9 @@
 ---
-### THIS SOFTWARE IS DEPRECIATED -- SEE HBLINK3 ###
+### FOR SUPPORT, DISCUSSION, GETTING INVOLVED ###
 
-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.
+Please join the DVSwitch group at groups.io for online forum support, discussion, and to become part of the development team.
+
+DVSwitch@groups.io 
 
 ---
 
@@ -17,10 +19,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 absolutely no warranty, express or implied. Use this software at your own risk.
+None. The owners of this work make absolutley no warranty, express or implied. Use this software at your own risk.
 
 **PRE-REQUISITE KNOWLEDGE:**  
-This document assumes the reader is familiar with Linux/UNIX, the Python programming language and DMR.  
+This document assumes the reader is familiar with 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-2018 Cortney T. Buffington, N0MJS <n0mjs@me.com>
+#   Copyright (C) 2016  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,29 +37,23 @@ 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 Factory, Protocol
+from twisted.internet.protocol import DatagramProtocol
-from twisted.protocols.basic import NetstringReceiver
+from twisted.internet import reactor
-from twisted.internet import reactor, task
+from twisted.internet import task
 
 # Things we import from the main hblink module
-from hblink import HBSYSTEM, OPENBRIDGE, systems, hblink_handler, reportFactory, REPORT_OPCODES, config_reports, mk_aliases
+from hblink import HBSYSTEM, systems, int_id, hblink_handler
 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-2018 Cortney T. Buffington, N0MJS and the K0USY Group'
+__copyright__  = 'Copyright (c) 2016 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'
@@ -71,8 +65,8 @@ __status__     = 'pre-alpha'
 
 class bridgeallSYSTEM(HBSYSTEM):
     
-    def __init__(self, _name, _config, _report):
+    def __init__(self, _name, _config, _logger):
-        HBSYSTEM.__init__(self, _name, _config, _report)
+        HBSYSTEM.__init__(self, _name, _config, _logger)
         
         # Status information for the system, TS1 & TS2
         # 1 & 2 are "timeslot"
@@ -124,7 +118,7 @@ class bridgeallSYSTEM(HBSYSTEM):
                 }
             }
 
-    def dmrd_received(self, _peer_id, _rf_src, _dst_id, _seq, _slot, _call_type, _frame_type, _dtype_vseq, _stream_id, _data):
+    def dmrd_received(self, _radio_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])
@@ -134,14 +128,20 @@ 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
-                logger.info('(%s) *CALL START* STREAM ID: %s SUB: %s (%s) PEER: %s (%s) TGID %s (%s), TS %s', \
+                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(_peer_id, peer_ids), int_id(_peer_id), get_alias(_dst_id, talkgroup_ids), int_id(_dst_id), _slot)
+                        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)
+            
             
             # 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']
-                logger.info('(%s) *CALL END*   STREAM ID: %s SUB: %s (%s) PEER: %s (%s) TGID %s (%s), TS %s, Duration: %s', \
+                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(_peer_id, peer_ids), int_id(_peer_id), get_alias(_dst_id, talkgroup_ids), int_id(_dst_id), _slot, call_duration)
+                        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)
             
             # Mark status variables for use later
             self.STATUS[_slot]['RX_RFS']       = _rf_src
@@ -151,57 +151,12 @@ class bridgeallSYSTEM(HBSYSTEM):
             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)
-                
-
 #************************************************
 #      MAIN PROGRAM LOOP STARTS HERE
 #************************************************
 
 if __name__ == '__main__':
+    
     import argparse
     import sys
     import os
@@ -228,13 +183,12 @@ 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)
+        hblink_handler(_signal, _frame, logger)
         logger.info('SHUTDOWN: ALL SYSTEM HANDLERS EXECUTED - STOPPING REACTOR')
         reactor.stop()
         
@@ -242,21 +196,35 @@ if __name__ == '__main__':
     for sig in [signal.SIGTERM, signal.SIGINT]:
         signal.signal(sig, sig_handler)
     
-    # Create the name-number mapping dictionaries
+    # ID ALIAS CREATION
-    peer_ids, subscriber_ids, talkgroup_ids = mk_aliases(CONFIG)
+    # 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')
         
-    # INITIALIZE THE REPORTING LOOP
-    report_server = config_reports(CONFIG, reportFactory)
     
     # HBlink instance creation
-    logger.info('HBlink \'hb_bridge_all.py\' -- SYSTEM STARTING...')
+    logger.info('HBlink \'hb_bridge_all.py\' (c) 2016 N0MJS & the K0USY Group - SYSTEM STARTING...')
     for system in CONFIG['SYSTEMS']:
         if CONFIG['SYSTEMS'][system]['ENABLED']:
-            if CONFIG['SYSTEMS'][system]['MODE'] == 'OPENBRIDGE':
+            systems[system] = bridgeallSYSTEM(system, CONFIG, logger)
-                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])
 

hb_confbridge.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 #
 ###############################################################################
-#   Copyright (C) 2016-2018 Cortney T. Buffington, N0MJS <n0mjs@me.com>
+#   Copyright (C) 2016  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,58 +40,29 @@ from time import time
 from importlib import import_module
 
 # Twisted is pretty important, so I keep it separate
-from twisted.internet.protocol import Factory, Protocol
+from twisted.internet.protocol import DatagramProtocol
-from twisted.protocols.basic import NetstringReceiver
+from twisted.internet import reactor
-from twisted.internet import reactor, task
+from twisted.internet import task
 
 # Things we import from the main hblink module
-from hblink import HBSYSTEM, OPENBRIDGE, systems, hblink_handler, reportFactory, REPORT_OPCODES, mk_aliases
+from hblink import HBSYSTEM, systems, hblink_handler
 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-2018 Cortney T. Buffington, N0MJS and the K0USY Group'
+__copyright__  = 'Copyright (c) 2016 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, 
@@ -116,16 +87,65 @@ def make_bridges(_hb_confbridge_bridges):
             for i, e in enumerate(_system['OFF']):
                 _system['OFF'][i] = hex_str_3(_system['OFF'][i])
             _system['TIMEOUT']    = _system['TIMEOUT']*60
-            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:
+        logger.info('ACL file found, importing entries. This will take about 1.5 seconds per 1 million IDs')
+        acl_file = import_module(_sub_acl)
+        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'
+
+    # 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_ACTION == 'PERMIT':
+        def allow_sub(_sub):
+            if _sub in ACL:
+                return True
+            else:
+                return False
+    elif 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
+
+
 # Run this every minute for rule timer updates
 def rule_timer_loop():
-    logger.debug('(ALL HBSYSTEMS) Rule timer loop started')
+    logger.info('(ALL HBSYSTEMS) Rule timer loop started')
     _now = time()
 
     for _bridge in BRIDGES:
@@ -153,259 +173,11 @@ 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')
 
+class routerSYSTEM(HBSYSTEM):
     
-# run this every 10 seconds to trim orphaned stream ids
+    def __init__(self, _name, _config, _logger):
-def stream_trimmer_loop():
+        HBSYSTEM.__init__(self, _name, _config, _logger)
-    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)
         
         # Status information for the system, TS1 & TS2
         # 1 & 2 are "timeslot"
@@ -413,12 +185,9 @@ class routerHBP(HBSYSTEM):
         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',
@@ -426,7 +195,6 @@ class routerHBP(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',
@@ -439,12 +207,9 @@ class routerHBP(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',
@@ -452,7 +217,6 @@ class routerHBP(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',
@@ -465,25 +229,28 @@ class routerHBP(HBSYSTEM):
                 }
             }
 
-    def dmrd_received(self, _peer_id, _rf_src, _dst_id, _seq, _slot, _call_type, _frame_type, _dtype_vseq, _stream_id, _data):
+    def dmrd_received(self, _radio_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?   
             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']):
-                    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)
+                    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)
                     return
                 
                 # This is a new call stream
-                self.STATUS[_slot]['RX_START'] = pkt_time
+                self.STATUS['RX_START'] = pkt_time
-                logger.info('(%s) *CALL START* STREAM ID: %s SUB: %s (%s) PEER: %s (%s) TGID %s (%s), TS %s', \
+                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(_peer_id, peer_ids), int_id(_peer_id), get_alias(_dst_id, talkgroup_ids), int_id(_dst_id), _slot)
+                        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)
-                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:
@@ -495,6 +262,7 @@ class routerHBP(HBSYSTEM):
                 else:
                     self.STATUS[_slot]['RX_LC'] = const.LC_OPT + _dst_id + _rf_src
 
+
             for _bridge in BRIDGES:
                 for _system in BRIDGES[_bridge]:
  
@@ -506,56 +274,7 @@ class routerHBP(HBSYSTEM):
                                     _target_status = systems[_target['SYSTEM']].STATUS
                                     _target_system = self._CONFIG['SYSTEMS'][_target['SYSTEM']]
                                 
-                                    if _target_system['MODE'] == 'OPENBRIDGE':
+                                    # BEGIN CONTENTION HANDLING
-                                        # 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:
-                                        # 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
@@ -566,42 +285,36 @@ class routerHBP(HBSYSTEM):
                                     #
                                     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']))
+                                            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:
-                                                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']))
+                                            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:
-                                                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']))
+                                            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:
-                                                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']))
+                                            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
                                 
-                                        # Is this a new call stream? 
+                                    # 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_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']))
+                                        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']))
-                                             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']))
+                                        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']))
-                                             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']:
@@ -623,9 +336,6 @@ class routerHBP(HBSYSTEM):
                                     # 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]
@@ -634,17 +344,15 @@ class routerHBP(HBSYSTEM):
                     
                                     # 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']))
+                                    #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']))
             
             
             
             # 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[_slot]['RX_START']
+                call_duration = pkt_time - self.STATUS['RX_START']
-                logger.info('(%s) *CALL END*   STREAM ID: %s SUB: %s (%s) PEER: %s (%s) TGID %s (%s), TS %s, Duration: %s', \
+                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(_peer_id, peer_ids), int_id(_peer_id), get_alias(_dst_id, talkgroup_ids), int_id(_dst_id), _slot, call_duration)
+                        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)
-                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.
@@ -659,44 +367,20 @@ class routerHBP(HBSYSTEM):
                             # 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']
-                                logger.info('(%s) Transmission match for Bridge: %s. Reset timeout to %s', self._system, _bridge, _system['TIMER'])
+                                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'] 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:
+                                # Set the matching rule as ACTIVE
                                 _system['ACTIVE'] = True
                                 _system['TIMER'] = pkt_time + _system['TIMEOUT']
-                                        logger.info('(%s) Bridge: %s, connection changed to state: %s', self._system, _bridge, _system['ACTIVE'])
+                                self._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:
+                                # Set the matching rule as ACTIVE
                                 _system['ACTIVE'] = False
-                                        logger.info('(%s) Bridge: %s, connection changed to state: %s', self._system, _bridge, _system['ACTIVE'])
+                                self._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
@@ -704,7 +388,6 @@ class routerHBP(HBSYSTEM):
                 
                 
             # 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
@@ -712,18 +395,6 @@ class routerHBP(HBSYSTEM):
             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
@@ -735,6 +406,7 @@ if __name__ == '__main__':
     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])))
@@ -756,53 +428,58 @@ 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: CONFBRIDGE IS TERMINATING WITH SIGNAL %s', str(_signal))
+        logger.info('SHUTDOWN: HBROUTER IS TERMINATING WITH SIGNAL %s', str(_signal))
-        hblink_handler(_signal, _frame)
+        hblink_handler(_signal, _frame, logger)
         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.SIGINT, signal.SIGTERM]:
+    for sig in [signal.SIGTERM, signal.SIGINT]:
         signal.signal(sig, sig_handler)
     
-    # Create the name-number mapping dictionaries
+    # ID ALIAS CREATION
-    peer_ids, subscriber_ids, talkgroup_ids = mk_aliases(CONFIG)
+    # 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')
     
     # Build the routing rules file
     BRIDGES = make_bridges('hb_confbridge_rules')
     
-    # INITIALIZE THE REPORTING LOOP
+    # Build the Access Control List
-    report_server = config_reports(CONFIG, confbridgeReportFactory)
+    ACL = build_acl('sub_acl')
     
     # HBlink instance creation
-    logger.info('HBlink \'hb_confbridge.py\' -- SYSTEM STARTING...')
+    logger.info('HBlink \'hb_router.py\' (c) 2016 N0MJS & the K0USY Group - SYSTEM STARTING...')
     for system in CONFIG['SYSTEMS']:
         if CONFIG['SYSTEMS'][system]['ENABLED']:
-            if CONFIG['SYSTEMS'][system]['MODE'] == 'OPENBRIDGE':
+            systems[system] = routerSYSTEM(system, CONFIG, logger)
-                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])
             
-    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 = task.LoopingCall(rule_timer_loop)
-    rule_timer = rule_timer_task.start(60)
+    rule_timer.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,23 +25,21 @@ 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], 'RESET': []},
+            {'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], 'RESET': []},
+            {'SYSTEM': 'CLIENT-1',    'TS': 1, 'TGID': 3100, 'ACTIVE': True, 'TIMEOUT': 2, 'TO_TYPE': 'ON',  'ON': [2,], 'OFF': [9,10]},
         ],
     'ENGLISH': [
-            {'SYSTEM': 'MASTER-1',    'TS': 1, 'TGID': 13,   'ACTIVE': True, 'TIMEOUT': 2, 'TO_TYPE': 'NONE', 'ON': [3,], 'OFF': [8,10], 'RESET': []},
+            {'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], 'RESET': []},
+            {'SYSTEM': 'CLIENT-2',    'TS': 1, 'TGID': 13,   'ACTIVE': True, 'TIMEOUT': 2, 'TO_TYPE': 'NONE', 'ON': [3,], 'OFF': [8,10]},
         ],
     'STATEWIDE': [
-            {'SYSTEM': 'MASTER-1',    'TS': 2, 'TGID': 3129, 'ACTIVE': True, 'TIMEOUT': 2, 'TO_TYPE': 'NONE', 'ON': [4,], 'OFF': [7,10], 'RESET': []},
+            {'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], 'RESET': []},
+            {'SYSTEM': 'CLIENT-2',    'TS': 2, 'TGID': 3129, 'ACTIVE': True, 'TIMEOUT': 2, 'TO_TYPE': 'NONE', 'ON': [4,], 'OFF': [7,10]},
         ]
 }
 

hb_config.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 #
 ###############################################################################
-#   Copyright (C) 2016-2018 Cortney T. Buffington, N0MJS <n0mjs@me.com>
+#   Copyright (C) 2016  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,73 +28,17 @@ 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-2018 Cortney T. Buffington, N0MJS and the K0USY Group'
+__copyright__  = 'Copyright (c) 2016 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()
@@ -104,9 +48,9 @@ def build_config(_config_file):
 
     CONFIG = {}
     CONFIG['GLOBAL'] = {}
-    CONFIG['REPORTS'] = {}
     CONFIG['LOGGER'] = {}
     CONFIG['ALIASES'] = {}
+    CONFIG['AMBE'] = {}
     CONFIG['SYSTEMS'] = {}
 
     try:
@@ -115,20 +59,7 @@ 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':
@@ -151,16 +82,21 @@ 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') == 'PEER':
+                if config.get(section, 'MODE') == 'CLIENT':
                     CONFIG['SYSTEMS'].update({section: {
                         'MODE': config.get(section, 'MODE'),
                         'ENABLED': config.getboolean(section, 'ENABLED'),
                         'LOOSE': config.getboolean(section, 'LOOSE'),
-                        'SOCK_ADDR': (gethostbyname(config.get(section, 'IP')), config.getint(section, 'PORT')),
+                        'EXPORT_AMBE': config.getboolean(section, 'EXPORT_AMBE'),
                         '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'),
@@ -180,15 +116,10 @@ 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,
@@ -202,44 +133,24 @@ def build_config(_config_file):
                         'MODE': config.get(section, 'MODE'),
                         'ENABLED': config.getboolean(section, 'ENABLED'),
                         'REPEAT': config.getboolean(section, 'REPEAT'),
-                        'MAX_PEERS': config.getint(section, 'MAX_PEERS'),
+                        'EXPORT_AMBE': config.getboolean(section, 'EXPORT_AMBE'),
                         '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({'PEERS': {}})
+                    CONFIG['SYSTEMS'][section].update({'CLIENTS': {}})
-                    
-                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:
-        sys.exit('Error processing configuration file -- {}'.format(err))
+	    print "Cannot parse configuration file. %s" %err
-        
+            sys.exit('Could not parse configuration file, exiting...')
-    process_acls(CONFIG)
         
     return CONFIG
 
+
+
+
+
 # Used to run this file direclty and print the config,
 # which might be useful for debugging
 if __name__ == '__main__':
@@ -247,7 +158,6 @@ 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])))
@@ -262,14 +172,5 @@ 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)
     
-    def acl_check(_id, _acl):
+    pprint(build_config(cli_args.CONFIG_FILE))
-        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-2018  Cortney T. Buffington, N0MJS <n0mjs@me.com>
+#   Copyright (C) 2016  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,11 +33,6 @@ __license__    = 'GNU GPLv3'
 __maintainer__ = 'Cort Buffington, N0MJS'
 __email__      = 'n0mjs@me.com'
 
-
-# DMR Related constants
-ID_MIN = 1
-ID_MAX = 16776415
-
 # Timers
 STREAM_TO = .360
 
@@ -47,9 +42,3 @@ HBPF_VOICE_SYNC = 0x1
 HBPF_DATA_SYNC  = 0x2
 HBPF_SLT_VHEAD  = 0x1
 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-2018  Cortney T. Buffington, N0MJS <n0mjs@me.com>
+#   Copyright (C) 2016  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-2018 Cortney T. Buffington, N0MJS and the K0USY Group'
+__copyright__  = 'Copyright (c) 2016 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,11 +83,13 @@ def config_logging(_logger):
                 'formatter': 'syslog',
             }
         },
-        'root': {
+        'loggers': {
+            _logger['LOG_NAME']: {
                 '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-2018  Cortney T. Buffington, N0MJS <n0mjs@me.com> (and Mike Zingman N4IRR)
+#   Copyright (C) 2016  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,23 +30,18 @@ from time import time, sleep
 from importlib import import_module
 
 # Twisted is pretty important, so I keep it separate
-from twisted.internet.protocol import Factory, Protocol
+from twisted.internet.protocol import DatagramProtocol
-from twisted.protocols.basic import NetstringReceiver
+from twisted.internet import reactor
-from twisted.internet import reactor, task
+from twisted.internet import task
 
 # Things we import from the main hblink module
-from hblink import HBSYSTEM, systems, hblink_handler, reportFactory, REPORT_OPCODES, config_reports, mk_aliases
+from hblink import HBSYSTEM, systems, int_id, hblink_handler
 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'
@@ -60,8 +55,8 @@ __status__     = 'pre-alpha'
 
 class parrot(HBSYSTEM):
     
-    def __init__(self, _name, _config, _report):
+    def __init__(self, _name, _config, _logger):
-        HBSYSTEM.__init__(self, _name, _config, _report)
+        HBSYSTEM.__init__(self, _name, _config, _logger)
         
         # Status information for the system, TS1 & TS2
         # 1 & 2 are "timeslot"
@@ -114,29 +109,30 @@ class parrot(HBSYSTEM):
         }
         self.CALL_DATA = []
 
-    def dmrd_received(self, _peer_id, _rf_src, _dst_id, _seq, _slot, _call_type, _frame_type, _dtype_vseq, _stream_id, _data):
+    def dmrd_received(self, _radio_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
-                logger.info('(%s) *CALL START* STREAM ID: %s SUB: %s (%s) REPEATER: %s (%s) TGID %s (%s), TS %s', \
+                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(_peer_id, peer_ids), int_id(_peer_id), get_alias(_dst_id, talkgroup_ids), int_id(_dst_id), _slot)
+                                  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)
         
             
             # 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']
-                logger.info('(%s) *CALL END*   STREAM ID: %s SUB: %s (%s) REPEATER: %s (%s) TGID %s (%s), TS %s, Duration: %s', \
+                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(_peer_id, peer_ids), int_id(_peer_id), get_alias(_dst_id, talkgroup_ids), int_id(_dst_id), _slot, call_duration)
+                                  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.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_system(i)
+                    self.send_clients(i)
                     sleep(0.06)
                 self.CALL_DATA = []
             
@@ -186,13 +182,12 @@ 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)
+        hblink_handler(_signal, _frame, logger)
         logger.info('SHUTDOWN: ALL SYSTEM HANDLERS EXECUTED - STOPPING REACTOR')
         reactor.stop()
         
@@ -210,21 +205,25 @@ if __name__ == '__main__':
         result = try_download(CONFIG['ALIASES']['PATH'], CONFIG['ALIASES']['SUBSCRIBER_FILE'], CONFIG['ALIASES']['SUBSCRIBER_URL'], CONFIG['ALIASES']['STALE_TIME'])
         logger.info(result)
         
-    # Create the name-number mapping dictionaries
+    # Make Dictionaries
-    peer_ids, subscriber_ids, talkgroup_ids = mk_aliases(CONFIG)
+    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')
         
-    # INITIALIZE THE REPORTING LOOP
-    report_server = config_reports(CONFIG, reportFactory)    
     
     # HBlink instance creation
-    logger.info('HBlink \'hb_parrot.py\' (c) 2017 Mike Zingman, N4IRR -- SYSTEM STARTING...')
+    logger.info('HBlink \'hb_parrot.py\' (c) 2016 N0MJS & the K0USY Group - SYSTEM STARTING...')
     for system in CONFIG['SYSTEMS']:
         if CONFIG['SYSTEMS'][system]['ENABLED']:
-            if CONFIG['SYSTEMS'][system]['MODE'] == 'OPENBRIDGE':
+            systems[system] = parrot(system, CONFIG, logger)
-                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])
 

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 Factory, Protocol
+from twisted.internet.protocol import DatagramProtocol
-from twisted.protocols.basic import NetstringReceiver
+from twisted.internet import reactor
-from twisted.internet import reactor, task
+from twisted.internet import task
 
 # Things we import from the main hblink module
-from hblink import HBSYSTEM, systems, hblink_handler, reportFactory, REPORT_OPCODES, config_reports
+from hblink import HBSYSTEM, systems, int_id, hblink_handler
 from dmr_utils.utils import hex_str_3, int_id, get_alias
 from dmr_utils import decode, bptc, const
 import hb_config
@@ -174,8 +174,8 @@ def rule_timer_loop():
 
 class routerSYSTEM(HBSYSTEM):
     
-    def __init__(self, _name, _config, _logger, _report):
+    def __init__(self, _name, _config, _logger):
-        HBSYSTEM.__init__(self, _name, _config, _logger, _report)
+        HBSYSTEM.__init__(self, _name, _config, _logger)
         
         # Status information for the system, TS1 & TS2
         # 1 & 2 are "timeslot"
@@ -227,7 +227,7 @@ class routerSYSTEM(HBSYSTEM):
                 }
             }
 
-    def dmrd_received(self, _peer_id, _rf_src, _dst_id, _seq, _slot, _call_type, _frame_type, _dtype_vseq, _stream_id, _data):
+    def dmrd_received(self, _radio_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])
@@ -236,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(_peer_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(_radio_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 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)
+                    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)
                     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) PEER: %s (%s) TGID %s (%s), TS %s', \
+                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(_peer_id, peer_ids), int_id(_peer_id), get_alias(_dst_id, talkgroup_ids), int_id(_dst_id), _slot)
+                        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)
                 
                 # 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:
@@ -345,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) PEER: %s (%s) TGID %s (%s), TS %s, Duration: %s', \
+                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(_peer_id, peer_ids), int_id(_peer_id), get_alias(_dst_id, talkgroup_ids), int_id(_dst_id), _slot, call_duration)
+                        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)
                 
                 #
                 # Begin in-band signalling for call end. This has nothign to do with routing traffic directly.
@@ -480,14 +480,11 @@ 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, report_server)
+            systems[system] = routerSYSTEM(system, CONFIG, logger)
             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,77 +1,19 @@
 # PROGRAM-WIDE PARAMETERS GO HERE
 # PATH - working path for files, leave it alone unless you NEED to change it
-# PING_TIME - the interval that peers will ping the master, and re-try registraion
+# PING_TIME - the interval that clients 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 peer
+#           - number of times the master maintenance loop runs before de-registering a client
-#
-# 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_HANDLERS may be any of the following, please, no spaces in the
+#   LOG_HANDERLS may be any of the following, please, no spaces in the
 #   list if you use several:
 #       null
 #       console
@@ -86,7 +28,7 @@ REPORT_CLIENTS: 127.0.0.1
 [LOGGER]
 LOG_FILE: /tmp/hblink.log
 LOG_HANDLERS: console-timed
-LOG_LEVEL: DEBUG
+LOG_LEVEL: INFO
 LOG_NAME: HBlink
 
 # DOWNLOAD AND IMPORT SUBSCRIBER, PEER and TGID ALIASES
@@ -105,66 +47,30 @@ PEER_URL: https://www.radioid.net/static/rptrs.json
 SUBSCRIBER_URL: https://www.radioid.net/static/users.json
 STALE_DAYS: 7
 
-# OPENBRIDGE INSTANCES - DUPLICATE SECTION FOR MULTIPLE CONNECTIONS
+# EXPORT AMBE DATA
-# OpenBridge is a protocol originall created by DMR+ for connection between an
+# This is for exporting AMBE audio frames to an an "external" process for
-# IPSC2 server and Brandmeister. It has been implemented here at the suggestion
+# decoding or other nefarious actions.
-# of the Brandmeister team as a way to legitimately connect HBlink to the
+[AMBE]
-# Brandemiester network.
+EXPORT_IP: 127.0.0.1
-# It is recommended to name the system the ID of the Brandmeister server that
+EXPORT_PORT: 1234
-# 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 peers, False, it does nothing.
+# Repeat - if True, the master repeats traffic to clients, 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
 
-# PEER INSTANCES - DUPLICATE SECTION FOR MULTIPLE PEERS
+# CLIENT INSTANCES - DUPLICATE SECTION FOR MULTIPLE CLIENTS
 # 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.
@@ -173,12 +79,9 @@ TGID_TS2_ACL: PERMIT:ALL
 # 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: PEER
+MODE: CLIENT
-ENABLED: True
+ENABLED: False
 LOOSE: False
 EXPORT_AMBE: False
 IP: 
@@ -186,24 +89,20 @@ PORT: 54001
 MASTER_IP: 172.16.1.1
 MASTER_PORT: 54000
 PASSPHRASE: homebrew
-CALLSIGN: W1ABC
+CALLSIGN: W1AW
-RADIO_ID: 312000
+RADIO_ID: 1234567
-RX_FREQ: 449000000
+RX_FREQ: 222340000
-TX_FREQ: 444000000
+TX_FREQ: 223940000
 TX_POWER: 25
 COLORCODE: 1
-SLOTS: 1
+SLOTS: 3
-LATITUDE: 38.0000
+LATITUDE: 41.7333
-LONGITUDE: -095.0000
+LONGITUDE: -50.3999
 HEIGHT: 75
-LOCATION: Anywhere, USA
+LOCATION: Iceberg, USA
-DESCRIPTION: This is a cool repeater
+DESCRIPTION: HBlink repeater
-URL: www.w1abc.org
+URL: https://groups.io/g/DVSwitch
 SOFTWARE_ID: 20170620
 PACKAGE_ID: MMDVM_HBlink
 GROUP_HANGTIME: 5
 OPTIONS: 
-USE_ACL: True
-SUB_ACL: DENY:1
-TGID_TS1_ACL: PERMIT:ALL
-TGID_TS2_ACL: PERMIT:ALL

hblink.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 #
 ###############################################################################
-#   Copyright (C) 2016-2018 Cortney T. Buffington, N0MJS <n0mjs@me.com>
+#   Copyright (C) 2016  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
@@ -20,11 +20,11 @@
 
 '''
 This program does very little on it's own. It is intended to be used as a module
-to build applications on top of the HomeBrew Repeater Protocol. By itself, it
+to build applcaitons on top of the HomeBrew Repeater Protocol. By itself, it
-will only act as a peer or master for the systems specified in its configuration
+will only act as a client or master for the systems specified in its configuration
 file (usually hblink.cfg). It is ALWAYS best practice to ensure that this program
-works stand-alone before troubleshooting any applications that use it. It has
+works stand-alone before troubleshooting any applicaitons that use it. It has
-sufficient logging to be used standalone as a troubleshooting application.
+sufficient logging to be used standalone as a troubeshooting application.
 '''
 
 from __future__ import print_function
@@ -33,171 +33,76 @@ from __future__ import print_function
 from binascii import b2a_hex as ahex
 from binascii import a2b_hex as bhex
 from random import randint
-from hashlib import sha256, sha1
+from hashlib import sha256
-from hmac import new as hmac_new, compare_digest
 from time import time
 from bitstring import BitArray
-from importlib import import_module
+import socket
-from collections import deque
+import sys
 
 # Twisted is pretty important, so I keep it separate
-from twisted.internet.protocol import DatagramProtocol, Factory, Protocol
+from twisted.internet.protocol import DatagramProtocol
-from twisted.protocols.basic import NetstringReceiver
+from twisted.internet import reactor
-from twisted.internet import reactor, task
+from twisted.internet import task
 
 # Other files we pull from -- this is mostly for readability and segmentation
 import hb_log
 import hb_config
-import hb_const as const
+from dmr_utils.utils import int_id, hex_str_4
-from dmr_utils.utils import int_id, hex_str_4, try_download, mk_id_dict
-
-# Imports for the reporting server
-import cPickle as pickle
-from reporting_const import *
-
-# 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-2018 Cortney T. Buffington, N0MJS and the K0USY Group'
+__copyright__  = 'Copyright (c) 2016 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'
 
+
 # Global variables used whether we are a module or __main__
 systems = {}
 
-# Timed loop used for reporting HBP status
+# Shut ourselves down gracefully by disconnecting from the masters and clients.
-#
+def hblink_handler(_signal, _frame, _logger):
-# 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()
-
-        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
-
-
-# Shut ourselves down gracefully by disconnecting from the masters and peers.
-def hblink_handler(_signal, _frame):
     for system in systems:
-        logger.info('SHUTDOWN: DE-REGISTER SYSTEM: %s', system)
+        _logger.info('SHUTDOWN: DE-REGISTER SYSTEM: %s', system)
         systems[system].dereg()
 
-# Check a supplied ID against the ACL provided. Returns action (True|False) based
-# on matching and the action specified.
-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]
-
 
 #************************************************
-#    OPENBRIDGE CLASS
+#     AMBE CLASS: Used to parse out AMBE and send to gateway
 #************************************************
 
-class OPENBRIDGE(DatagramProtocol):
+class AMBE:
-    def __init__(self, _name, _config, _report):
+    def __init__(self, _config, _logger):
-        # Define a few shortcuts to make the rest of the class more readable
         self._CONFIG = _config
-        self._system = _name
-        self._report = _report
-        self._config = self._CONFIG['SYSTEMS'][self._system]
-        self._laststrid = deque([], 20)
          
-    def dereg(self):
+        self._sock = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
-        logger.info('(%s) is mode OPENBRIDGE. No De-Registration required, continuing shutdown', self._system)
+        self._exp_ip = self._CONFIG['AMBE']['EXPORT_IP']
+        self._exp_port = self._CONFIG['AMBE']['EXPORT_PORT']
 
-    def send_system(self, _packet):
+    def parseAMBE(self, _client, _data):
-        if _packet[:4] == 'DMRD':
+        _seq = int_id(_data[4:5])
-            _packet = _packet[:11] + self._config['NETWORK_ID'] + _packet[15:]
+        _srcID = int_id(_data[5:8])
-            _packet += hmac_new(self._config['PASSPHRASE'],_packet,sha1).digest()
+        _dstID = int_id(_data[8:11])
-            self.transport.write(_packet, (self._config['TARGET_IP'], self._config['TARGET_PORT']))
+        _rptID = int_id(_data[11:15])
-            # KEEP THE FOLLOWING COMMENTED OUT UNLESS YOU'RE DEBUGGING DEEPLY!!!!
+        _bits = int_id(_data[15:16])       # SCDV NNNN (Slot|Call type|Data|Voice|Seq or Data type)
-            # logger.debug('(%s) TX Packet to OpenBridge %s:%s -- %s', self._system, self._config['TARGET_IP'], self._config['TARGET_PORT'], ahex(_packet))
+        _slot = 2 if _bits & 0x80 else 1
-        else:
+        _callType = 1 if (_bits & 0x40) else 0
-            logger.error('(%s) OpenBridge system was asked to send non DMRD packet', self._system)
+        _frameType = (_bits & 0x30) >> 4
+        _voiceSeq = (_bits & 0x0f)
+        _streamID = int_id(_data[16:20])
+        logger.debug('(%s) seq: %d srcID: %d dstID: %d rptID: %d bits: %0X slot:%d callType: %d frameType:  %d voiceSeq: %d streamID: %0X',
+        _client, _seq, _srcID, _dstID, _rptID, _bits, _slot, _callType, _frameType, _voiceSeq, _streamID )
 
-    def dmrd_received(self, _peer_id, _rf_src, _dst_id, _seq, _slot, _call_type, _frame_type, _dtype_vseq, _stream_id, _data):
+        #logger.debug('Frame 1:(%s)', self.ByteToHex(_data))
-        pass
+        _dmr_frame = BitArray('0x'+ahex(_data[20:]))
-        #print(int_id(_peer_id), int_id(_rf_src), int_id(_dst_id), int_id(_seq), _slot, _call_type, _frame_type, repr(_dtype_vseq), int_id(_stream_id))
+        _ambe = _dmr_frame[0:108] + _dmr_frame[156:264]
+        #_sock.sendto(_ambe.tobytes(), ("127.0.0.1", 31000))
 
-    def datagramReceived(self, _packet, _sockaddr):
+        ambeBytes = _ambe.tobytes()
-        # Keep This Line Commented Unless HEAVILY Debugging!
+        self._sock.sendto(ambeBytes[0:9], (self._exp_ip, self._exp_port))
-        #logger.debug('(%s) RX packet from %s -- %s', self._system, _sockaddr, ahex(_packet))
+        self._sock.sendto(ambeBytes[9:18], (self._exp_ip, self._exp_port))
-
+        self._sock.sendto(ambeBytes[18:27], (self._exp_ip, self._exp_port))
-        if _packet[:4] == 'DMRD':    # DMRData -- encapsulated DMR data frame
-            _data = _packet[:53]
-            _hash = _packet[53:]
-            _ckhs = hmac_new(self._config['PASSPHRASE'],_data,sha1).digest()
-
-            if compare_digest(_hash, _ckhs) and _sockaddr == self._config['TARGET_SOCK']:
-                _peer_id = _data[11:15]
-                _seq = _data[4]
-                _rf_src = _data[5:8]
-                _dst_id = _data[8:11]
-                _bits = int_id(_data[15])
-                _slot = 2 if (_bits & 0x80) else 1
-                #_call_type = 'unit' if (_bits & 0x40) else 'group'
-                if _bits & 0x40:
-                    _call_type = 'unit'
-                elif (_bits & 0x23) == 0x23:
-                    _call_type = 'vcsbk'
-                else:
-                    _call_type = 'group'
-                _frame_type = (_bits & 0x30) >> 4
-                _dtype_vseq = (_bits & 0xF) # data, 1=voice header, 2=voice terminator; voice, 0=burst A ... 5=burst F
-                _stream_id = _data[16:20]
-                #logger.debug('(%s) DMRD - Seqence: %s, RF Source: %s, Destination ID: %s', self._system, int_id(_seq), int_id(_rf_src), int_id(_dst_id))
-
-                # Sanity check for OpenBridge -- all calls must be on Slot 1
-                if _slot != 1:
-                    logger.error('(%s) OpenBridge packet discarded because it was not received on slot 1. SID: %s, TGID %s', self._system, int_id(_rf_src), int_id(_dst_id))
-                    return
-
-                # ACL Processing
-                if self._CONFIG['GLOBAL']['USE_ACL']:
-                    if not acl_check(_rf_src, self._CONFIG['GLOBAL']['SUB_ACL']):
-                        if _stream_id not in self._laststrid:
-                            logger.info('(%s) CALL DROPPED WITH STREAM ID %s FROM SUBSCRIBER %s BY GLOBAL ACL', self._system, int_id(_stream_id), int_id(_rf_src))
-                            self._laststrid.append(_stream_id)
-                        return
-                    if _slot == 1 and not acl_check(_dst_id, self._CONFIG['GLOBAL']['TG1_ACL']):
-                        if _stream_id not in self._laststrid:
-                            logger.info('(%s) CALL DROPPED WITH STREAM ID %s ON TGID %s BY GLOBAL TS1 ACL', self._system, int_id(_stream_id), int_id(_dst_id))
-                            self._laststrid.append(_stream_id)
-                        return
-                if self._config['USE_ACL']:
-                    if not acl_check(_rf_src, self._config['SUB_ACL']):
-                        if _stream_id not in self._laststrid:
-                            logger.info('(%s) CALL DROPPED WITH STREAM ID %s FROM SUBSCRIBER %s BY SYSTEM ACL', self._system, int_id(_stream_id), int_id(_rf_src))
-                            self._laststrid.append(_stream_id)
-                        return
-                    if not acl_check(_dst_id, self._config['TG1_ACL']):
-                        if _stream_id not in self._laststrid:
-                            logger.info('(%s) CALL DROPPED WITH STREAM ID %s ON TGID %s BY SYSTEM ACL', self._system, int_id(_stream_id), int_id(_dst_id))
-                            self._laststrid.append(_stream_id)
-                        return
-
-                # Userland actions -- typically this is the function you subclass for an application
-                self.dmrd_received(_peer_id, _rf_src, _dst_id, _seq, _slot, _call_type, _frame_type, _dtype_vseq, _stream_id, _data)
-            else:
-                logger.info('(%s) OpenBridge HMAC failed, packet discarded - OPCODE: %s DATA: %s HMAC LENGTH: %s HMAC: %s', self._system, _packet[:4], repr(_packet[:53]), len(_packet[53:]), repr(_packet[53:])) 
 
 
 #************************************************
@@ -205,199 +110,158 @@ class OPENBRIDGE(DatagramProtocol):
 #************************************************
 
 class HBSYSTEM(DatagramProtocol):
-    def __init__(self, _name, _config, _report):
+    def __init__(self, _name, _config, _logger):
         # Define a few shortcuts to make the rest of the class more readable
         self._CONFIG = _config
         self._system = _name
-        self._report = _report
+        self._logger = _logger
         self._config = self._CONFIG['SYSTEMS'][self._system]
-        self._laststrid1 = ''
+        sys.excepthook = self.handle_exception
-        self._laststrid2 = ''
         
         # Define shortcuts and generic function names based on the type of system we are
         if self._config['MODE'] == 'MASTER':
-            self._peers = self._CONFIG['SYSTEMS'][self._system]['PEERS']
+            self._clients = self._CONFIG['SYSTEMS'][self._system]['CLIENTS']
-            self.send_system = self.send_peers
+            self.send_system = self.send_clients
             self.maintenance_loop = self.master_maintenance_loop
             self.datagramReceived = self.master_datagramReceived
             self.dereg = self.master_dereg
         
-        elif self._config['MODE'] == 'PEER':
+        elif self._config['MODE'] == 'CLIENT':
             self._stats = self._config['STATS']
             self.send_system = self.send_master
-            self.maintenance_loop = self.peer_maintenance_loop
+            self.maintenance_loop = self.client_maintenance_loop
-            self.datagramReceived = self.peer_datagramReceived
+            self.datagramReceived = self.client_datagramReceived
-            self.dereg = self.peer_dereg
+            self.dereg = self.client_dereg
+        
+        # Configure for AMBE audio export if enabled
+        if self._config['EXPORT_AMBE']:
+            self._ambe = AMBE()
+
+    def handle_exception(self, exc_type, exc_value, exc_traceback):
+        if issubclass(exc_type, KeyboardInterrupt):
+            sys.__excepthook__(exc_type, exc_value, exc_traceback)
+            return
+        self._logger.error("Uncaught exception", exc_info=(exc_type, exc_value, exc_traceback))
 
     def startProtocol(self):
-        # Set up periodic loop for tracking pings from peers. Run every 'PING_TIME' seconds
+        # Set up periodic loop for tracking pings from clients. Run every 'PING_TIME' seconds
         self._system_maintenance = task.LoopingCall(self.maintenance_loop)
         self._system_maintenance_loop = self._system_maintenance.start(self._CONFIG['GLOBAL']['PING_TIME'])
     
     # Aliased in __init__ to maintenance_loop if system is a master
     def master_maintenance_loop(self):
-        logger.debug('(%s) Master maintenance loop started', self._system)
+        self._logger.debug('(%s) Master maintenance loop started', self._system)
-        remove_list = []
+        for client in self._clients:
-        for peer in self._peers:
+            _this_client = self._clients[client]
-            _this_peer = self._peers[peer]
+            # Check to see if any of the clients have been quiet (no ping) longer than allowed
-            # Check to see if any of the peers have been quiet (no ping) longer than allowed
+            if _this_client['LAST_PING']+self._CONFIG['GLOBAL']['PING_TIME']*self._CONFIG['GLOBAL']['MAX_MISSED'] < time():
-            if _this_peer['LAST_PING']+(self._CONFIG['GLOBAL']['PING_TIME']*self._CONFIG['GLOBAL']['MAX_MISSED']) < time():
+                self._logger.info('(%s) Client %s (%s) has timed out', self._system, _this_client['CALLSIGN'], _this_client['RADIO_ID'])
-                remove_list.append(peer)
+                # Remove any timed out clients from the configuration
-        for peer in remove_list:
+                del self._CONFIG['SYSTEMS'][self._system]['CLIENTS'][client]
-            logger.info('(%s) Peer %s (%s) has timed out and is being removed', self._system, self._peers[peer]['CALLSIGN'], self._peers[peer]['RADIO_ID'])
-            # Remove any timed out peers from the configuration
-            del self._CONFIG['SYSTEMS'][self._system]['PEERS'][peer]
     
-    # Aliased in __init__ to maintenance_loop if system is a peer
+    # Aliased in __init__ to maintenance_loop if system is a client           
-    def peer_maintenance_loop(self):
+    def client_maintenance_loop(self):
-        logger.debug('(%s) Peer maintenance loop started', self._system)
+        self._logger.debug('(%s) Client maintenance loop started', self._system)
         if self._stats['PING_OUTSTANDING']:
             self._stats['NUM_OUTSTANDING'] += 1
         # If we're not connected, zero out the stats and send a login request RPTL
-        if self._stats['CONNECTION'] != 'YES' or self._stats['NUM_OUTSTANDING'] >= self._CONFIG['GLOBAL']['MAX_MISSED']:
+        if self._stats['CONNECTION'] == 'NO' or self._stats['CONNECTION'] == 'RPTL_SENT' or self._stats['NUM_OUTSTANDING'] >= self._CONFIG['GLOBAL']['MAX_MISSED']:
             self._stats['PINGS_SENT'] = 0
             self._stats['PINGS_ACKD'] = 0
             self._stats['NUM_OUTSTANDING'] = 0
             self._stats['PING_OUTSTANDING'] = False
             self._stats['CONNECTION'] = 'RPTL_SENT'
             self.send_master('RPTL'+self._config['RADIO_ID'])
-            logger.info('(%s) Sending login request to master %s:%s', self._system, self._config['MASTER_IP'], self._config['MASTER_PORT'])
+            self._logger.info('(%s) Sending login request to master %s:%s', self._system, self._config['MASTER_IP'], self._config['MASTER_PORT'])
         # If we are connected, sent a ping to the master and increment the counter
         if self._stats['CONNECTION'] == 'YES':
             self.send_master('RPTPING'+self._config['RADIO_ID'])
-            logger.debug('(%s) RPTPING Sent to Master. Total Sent: %s, Total Missed: %s, Currently Outstanding: %s', self._system, self._stats['PINGS_SENT'], self._stats['PINGS_SENT'] - self._stats['PINGS_ACKD'], self._stats['NUM_OUTSTANDING'])
+            self._logger.debug('(%s) RPTPING Sent to Master. Total Sent: %s, Total Missed: %s, Currently Outstanding: %s', self._system, self._stats['PINGS_SENT'], self._stats['PINGS_SENT'] - self._stats['PINGS_ACKD'], self._stats['NUM_OUTSTANDING'])
             self._stats['PINGS_SENT'] += 1
             self._stats['PING_OUTSTANDING'] = True
 
-    def send_peers(self, _packet):
+    def send_clients(self, _packet):
-        for _peer in self._peers:
+        for _client in self._clients:
-            self.send_peer(_peer, _packet)
+            self.send_client(_client, _packet)
-            #logger.debug('(%s) Packet sent to peer %s', self._system, self._peers[_peer]['RADIO_ID'])
+            #self._logger.debug('(%s) Packet sent to client %s', self._system, self._clients[_client]['RADIO_ID'])
 
-    def send_peer(self, _peer, _packet):
+    def send_client(self, _client, _packet):
-        #if _packet[:4] == 'DMRD':
+        _ip = self._clients[_client]['IP']
-        self.transport.write(''.join([_packet[:11], _peer, _packet[15:]]), self._peers[_peer]['SOCKADDR'])
+        _port = self._clients[_client]['PORT']
+        self.transport.write(_packet, (_ip, _port))
         # KEEP THE FOLLOWING COMMENTED OUT UNLESS YOU'RE DEBUGGING DEEPLY!!!!
-        #logger.debug('(%s) TX Packet to %s on port %s: %s', self._peers[_peer]['RADIO_ID'], self._peers[_peer]['IP'], self._peers[_peer]['PORT'], ahex(_packet))
+        #self._logger.debug('(%s) TX Packet to %s on port %s: %s', self._clients[_client]['RADIO_ID'], self._clients[_client]['IP'], self._clients[_client]['PORT'], ahex(_packet))
 
     def send_master(self, _packet):
-        if _packet[:4] == 'DMRD':
+        self.transport.write(_packet, (self._config['MASTER_IP'], self._config['MASTER_PORT']))
-            _packet = _packet[:11] + self._config['RADIO_ID'] + _packet[15:]
-        self.transport.write(_packet, self._config['MASTER_SOCKADDR'])
         # KEEP THE FOLLOWING COMMENTED OUT UNLESS YOU'RE DEBUGGING DEEPLY!!!!
-        # logger.debug('(%s) TX Packet to %s:%s -- %s', self._system, self._config['MASTER_IP'], self._config['MASTER_PORT'], ahex(_packet))
+        #self._logger.debug('(%s) TX Packet to %s:%s -- %s', self._system, self._config['MASTER_IP'], self._config['MASTER_PORT'], ahex(_packet))
 
-    def dmrd_received(self, _peer_id, _rf_src, _dst_id, _seq, _slot, _call_type, _frame_type, _dtype_vseq, _stream_id, _data):
+    def dmrd_received(self, _radio_id, _rf_src, _dst_id, _seq, _slot, _call_type, _frame_type, _dtype_vseq, _stream_id, _data):
         pass
     
     def master_dereg(self):
-        for _peer in self._peers:
+        for _client in self._clients:
-            self.send_peer(_peer, 'MSTCL'+_peer)
+            self.send_client(_client, 'MSTCL'+_client)
-            logger.info('(%s) De-Registration sent to Peer: %s (%s)', self._system, self._peers[_peer]['CALLSIGN'], self._peers[_peer]['RADIO_ID'])
+            self._logger.info('(%s) De-Registration sent to Client: %s (%s)', self._system, self._clients[_client]['CALLSIGN'], self._clients[_client]['RADIO_ID'])
             
-    def peer_dereg(self):
+    def client_dereg(self):
         self.send_master('RPTCL'+self._config['RADIO_ID'])
-        logger.info('(%s) De-Registration sent to Master: %s:%s', self._system, self._config['MASTER_SOCKADDR'][0], self._config['MASTER_SOCKADDR'][1])
+        self._logger.info('(%s) De-Registeration sent to Master: %s:%s', self._system, self._config['MASTER_IP'], self._config['MASTER_PORT'])
     
     # Aliased in __init__ to datagramReceived if system is a master
-    def master_datagramReceived(self, _data, _sockaddr):
+    def master_datagramReceived(self, _data, (_host, _port)):
         # Keep This Line Commented Unless HEAVILY Debugging!
-        # logger.debug('(%s) RX packet from %s -- %s', self._system, _sockaddr, ahex(_data))
+        #self._logger.debug('(%s) RX packet from %s:%s -- %s', self._system, _host, _port, ahex(_data))
 
         # Extract the command, which is various length, all but one 4 significant characters -- RPTCL
         _command = _data[:4]
 
         if _command == 'DMRD':    # DMRData -- encapsulated DMR data frame
-            _peer_id = _data[11:15]
+            _radio_id = _data[11:15]
-            if _peer_id in self._peers \
+            if _radio_id in self._clients \
-                        and self._peers[_peer_id]['CONNECTION'] == 'YES' \
+                        and self._clients[_radio_id]['CONNECTION'] == 'YES' \
-                        and self._peers[_peer_id]['SOCKADDR'] == _sockaddr:
+                        and self._clients[_radio_id]['IP'] == _host \
+                        and self._clients[_radio_id]['PORT'] == _port:
                 _seq = _data[4]
                 _rf_src = _data[5:8]
                 _dst_id = _data[8:11]
                 _bits = int_id(_data[15])
                 _slot = 2 if (_bits & 0x80) else 1
-                #_call_type = 'unit' if (_bits & 0x40) else 'group'
+                _call_type = 'unit' if (_bits & 0x40) else 'group'
-                if _bits & 0x40:
-                    _call_type = 'unit'
-                elif (_bits & 0x23) == 0x23:
-                    _call_type = 'vcsbk'
-                else:
-                    _call_type = 'group'
                 _frame_type = (_bits & 0x30) >> 4
                 _dtype_vseq = (_bits & 0xF) # data, 1=voice header, 2=voice terminator; voice, 0=burst A ... 5=burst F
                 _stream_id = _data[16:20]
-                #logger.debug('(%s) DMRD - Seqence: %s, RF Source: %s, Destination ID: %s', self._system, int_id(_seq), int_id(_rf_src), int_id(_dst_id))
+                #self._logger.debug('(%s) DMRD - Seqence: %s, RF Source: %s, Destination ID: %s', self._system, int_id(_seq), int_id(_rf_src), int_id(_dst_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.info('(%s) CALL DROPPED WITH STREAM ID %s FROM SUBSCRIBER %s BY GLOBAL ACL', self._system, int_id(_stream_id), int_id(_rf_src))
-                            if _slot == 1:
-                                self._laststrid1 = _stream_id
-                            else:
-                                self._laststrid2 = _stream_id
-                        return
-                    if _slot == 1 and not acl_check(_dst_id, self._CONFIG['GLOBAL']['TG1_ACL']):
-                        if self._laststrid1 != _stream_id:
-                            logger.info('(%s) CALL DROPPED WITH STREAM ID %s ON TGID %s BY GLOBAL TS1 ACL', self._system, int_id(_stream_id), int_id(_dst_id))
-                            self._laststrid1 = _stream_id
-                        return
-                    if _slot == 2 and not acl_check(_dst_id, self._CONFIG['GLOBAL']['TG2_ACL']):
-                        if self._laststrid2 != _stream_id:
-                            logger.info('(%s) CALL DROPPED WITH STREAM ID %s ON TGID %s BY GLOBAL TS2 ACL', self._system, int_id(_stream_id), int_id(_dst_id))
-                            self._laststrid2 = _stream_id
-                        return
-                if self._config['USE_ACL']:
-                    if not acl_check(_rf_src, self._config['SUB_ACL']):
-                        if self._laststrid != _stream_id:
-                            logger.info('(%s) CALL DROPPED WITH STREAM ID %s FROM SUBSCRIBER %s BY SYSTEM ACL', self._system, int_id(_stream_id), int_id(_rf_src))
-                            if _slot == 1:
-                                self._laststrid1 = _stream_id
-                            else:
-                                self._laststrid2 = _stream_id
-                        return
-                    if _slot == 1 and not acl_check(_dst_id, self._config['TG1_ACL']):
-                        if self._laststrid1 != _stream_id:
-                            logger.info('(%s) CALL DROPPED WITH STREAM ID %s ON TGID %s BY SYSTEM TS1 ACL', self._system, int_id(_stream_id), int_id(_dst_id))
-                            self._laststrid1 = _stream_id
-                        return
-                    if _slot == 2 and not acl_check(_dst_id, self._config['TG2_ACL']):
-                        if self._laststrid2 != _stream_id:
-                            logger.info('(%s) CALL DROPPED WITH STREAM ID %s ON TGID %s BY SYSTEM TS2 ACL', self._system, int_id(_stream_id), int_id(_dst_id))
-                            self._laststrid2 = _stream_id
-                        return
 
-                # The basic purpose of a master is to repeat to the peers
+                # If AMBE audio exporting is configured...
+                if self._config['EXPORT_AMBE']:
+                    self._ambe.parseAMBE(self._system, _data)
+
+                # The basic purpose of a master is to repeat to the clients
                 if self._config['REPEAT'] == True:
-                    pkt = [_data[:11], '', _data[15:]]
+                    for _client in self._clients:
-                    for _peer in self._peers:
+                        if _client != _radio_id:
-                        if _peer != _peer_id:
-                            pkt[1] = _peer
-                            self.transport.write(''.join(pkt), self._peers[_peer]['SOCKADDR'])
-                            #logger.debug('(%s) Packet on TS%s from %s (%s) for destination ID %s repeated to peer: %s (%s) [Stream ID: %s]', self._system, _slot, self._peers[_peer_id]['CALLSIGN'], int_id(_peer_id), int_id(_dst_id), self._peers[_peer]['CALLSIGN'], int_id(_peer), int_id(_stream_id))
 
+                            _data = _data[0:11] + _client + _data[15:]
+
+                            self.send_client(_client, _data)
+                            self._logger.debug('(%s) Packet on TS%s from %s (%s) for destination ID %s repeated to client: %s (%s) [Stream ID: %s]', self._system, _slot, self._clients[_radio_id]['CALLSIGN'], int_id(_radio_id), int_id(_dst_id), self._clients[_client]['CALLSIGN'], int_id(_client), int_id(_stream_id))
 
                 # Userland actions -- typically this is the function you subclass for an application
-                self.dmrd_received(_peer_id, _rf_src, _dst_id, _seq, _slot, _call_type, _frame_type, _dtype_vseq, _stream_id, _data)
+                self.dmrd_received(_radio_id, _rf_src, _dst_id, _seq, _slot, _call_type, _frame_type, _dtype_vseq, _stream_id, _data)
 
         elif _command == 'RPTL':    # RPTLogin -- a repeater wants to login
-            _peer_id = _data[4:8]
+            _radio_id = _data[4:8]
-            # Check to see if we've reached the maximum number of allowed peers
+            if _radio_id:           # Future check here for valid Radio ID
-            if len(self._peers) < self._config['MAX_PEERS']:
+                self._clients.update({_radio_id: {      # Build the configuration data strcuture for the client
-                # Check for valid Radio ID
-                if acl_check(_peer_id, self._CONFIG['GLOBAL']['REG_ACL']) and acl_check(_peer_id, self._config['REG_ACL']):
-                    # Build the configuration data strcuture for the peer
-                    self._peers.update({_peer_id: {
                     'CONNECTION': 'RPTL-RECEIVED',
-                        'CONNECTED': time(),
                     'PINGS_RECEIVED': 0,
                     'LAST_PING': time(),
-                        'SOCKADDR': _sockaddr,
+                    'IP': _host,
-                        'IP': _sockaddr[0],
+                    'PORT': _port,
-                        'PORT': _sockaddr[1],
                     'SALT': randint(0,0xFFFFFFFF),
-                        'RADIO_ID': str(int(ahex(_peer_id), 16)),
+                    'RADIO_ID': str(int(ahex(_radio_id), 16)),
                     'CALLSIGN': '',
                     'RX_FREQ': '',
                     'TX_FREQ': '',
@@ -413,190 +277,150 @@ class HBSYSTEM(DatagramProtocol):
                     'SOFTWARE_ID': '',
                     'PACKAGE_ID': '',
                 }})
-                    logger.info('(%s) Repeater Logging in with Radio ID: %s, %s:%s', self._system, int_id(_peer_id), _sockaddr[0], _sockaddr[1])
+                self._logger.info('(%s) Repeater Logging in with Radio ID: %s, %s:%s', self._system, int_id(_radio_id), _host, _port)
-                    _salt_str = hex_str_4(self._peers[_peer_id]['SALT'])
+                _salt_str = hex_str_4(self._clients[_radio_id]['SALT'])
-                    self.send_peer(_peer_id, 'RPTACK'+_salt_str)
+                self.send_client(_radio_id, 'RPTACK'+_salt_str)
-                    self._peers[_peer_id]['CONNECTION'] = 'CHALLENGE_SENT'
+                self._clients[_radio_id]['CONNECTION'] = 'CHALLENGE_SENT'
-                    logger.info('(%s) Sent Challenge Response to %s for login: %s', self._system, int_id(_peer_id), self._peers[_peer_id]['SALT'])
+                self._logger.info('(%s) Sent Challenge Response to %s for login: %s', self._system, int_id(_radio_id), self._clients[_radio_id]['SALT'])
             else:
-                    self.transport.write('MSTNAK'+_peer_id, _sockaddr)
+                self.transport.write('MSTNAK'+_radio_id, (_host, _port))
-                    logger.warning('(%s) Invalid Login from Radio ID: %s Denied by Registation ACL', self._system, int_id(_peer_id))
+                self._logger.warning('(%s) Invalid Login from Radio ID: %s', self._system, int_id(_radio_id))
-            else:
-                self.transport.write('MSTNAK'+_peer_id, _sockaddr)
-                logger.warning('(%s) Registration denied from Radio ID: %s Maximum number of peers exceeded', self._system, int_id(_peer_id))
 
         elif _command == 'RPTK':    # Repeater has answered our login challenge
-            _peer_id = _data[4:8]
+            _radio_id = _data[4:8]
-            if _peer_id in self._peers \
+            if _radio_id in self._clients \
-                        and self._peers[_peer_id]['CONNECTION'] == 'CHALLENGE_SENT' \
+                        and self._clients[_radio_id]['CONNECTION'] == 'CHALLENGE_SENT' \
-                        and self._peers[_peer_id]['SOCKADDR'] == _sockaddr:
+                        and self._clients[_radio_id]['IP'] == _host \
-                _this_peer = self._peers[_peer_id]
+                        and self._clients[_radio_id]['PORT'] == _port:
-                _this_peer['LAST_PING'] = time()
+                _this_client = self._clients[_radio_id]
+                _this_client['LAST_PING'] = time()
                 _sent_hash = _data[8:]
-                _salt_str = hex_str_4(_this_peer['SALT'])
+                _salt_str = hex_str_4(_this_client['SALT'])
                 _calc_hash = bhex(sha256(_salt_str+self._config['PASSPHRASE']).hexdigest())
                 if _sent_hash == _calc_hash:
-                    _this_peer['CONNECTION'] = 'WAITING_CONFIG'
+                    _this_client['CONNECTION'] = 'WAITING_CONFIG'
-                    self.send_peer(_peer_id, 'RPTACK'+_peer_id)
+                    self.send_client(_radio_id, 'RPTACK'+_radio_id)
-                    logger.info('(%s) Peer %s has completed the login exchange successfully', self._system, _this_peer['RADIO_ID'])
+                    self._logger.info('(%s) Client %s has completed the login exchange successfully', self._system, _this_client['RADIO_ID'])
                 else:
-                    logger.info('(%s) Peer %s has FAILED the login exchange successfully', self._system, _this_peer['RADIO_ID'])
+                    self._logger.info('(%s) Client %s has FAILED the login exchange successfully', self._system, _this_client['RADIO_ID'])
-                    self.transport.write('MSTNAK'+_peer_id, _sockaddr)
+                    self.transport.write('MSTNAK'+_radio_id, (_host, _port))
-                    del self._peers[_peer_id]
+                    del self._clients[_radio_id]
             else:
-                self.transport.write('MSTNAK'+_peer_id, _sockaddr)
+                self.transport.write('MSTNAK'+_radio_id, (_host, _port))
-                logger.warning('(%s) Login challenge from Radio ID that has not logged in: %s', self._system, int_id(_peer_id))
+                self._logger.warning('(%s) Login challenge from Radio ID that has not logged in: %s', self._system, int_id(_radio_id))
 
         elif _command == 'RPTC':    # Repeater is sending it's configuraiton OR disconnecting
             if _data[:5] == 'RPTCL':    # Disconnect command
-                _peer_id = _data[5:9]
+                _radio_id = _data[5:9]
-                if _peer_id in self._peers \
+                if _radio_id in self._clients \
-                            and self._peers[_peer_id]['CONNECTION'] == 'YES' \
+                            and self._clients[_radio_id]['CONNECTION'] == 'YES' \
-                            and self._peers[_peer_id]['SOCKADDR'] == _sockaddr:
+                            and self._clients[_radio_id]['IP'] == _host \
-                    logger.info('(%s) Peer is closing down: %s (%s)', self._system, self._peers[_peer_id]['CALLSIGN'], int_id(_peer_id))
+                            and self._clients[_radio_id]['PORT'] == _port:
-                    self.transport.write('MSTNAK'+_peer_id, _sockaddr)
+                    self._logger.info('(%s) Client is closing down: %s (%s)', self._system, self._clients[_radio_id]['CALLSIGN'], int_id(_radio_id))
-                    del self._peers[_peer_id]
+                    self.transport.write('MSTNAK'+_radio_id, (_host, _port))
+                    del self._clients[_radio_id]
 
             else:
-                _peer_id = _data[4:8]      # Configure Command
+                _radio_id = _data[4:8]      # Configure Command
-                if _peer_id in self._peers \
+                if _radio_id in self._clients \
-                            and self._peers[_peer_id]['CONNECTION'] == 'WAITING_CONFIG' \
+                            and self._clients[_radio_id]['CONNECTION'] == 'WAITING_CONFIG' \
-                            and self._peers[_peer_id]['SOCKADDR'] == _sockaddr:
+                            and self._clients[_radio_id]['IP'] == _host \
-                    _this_peer = self._peers[_peer_id]
+                            and self._clients[_radio_id]['PORT'] == _port:
-                    _this_peer['CONNECTION'] = 'YES'
+                    _this_client = self._clients[_radio_id]
-                    _this_peer['CONNECTED'] = time()
+                    _this_client['CONNECTION'] = 'YES'
-                    _this_peer['LAST_PING'] = time()
+                    _this_client['LAST_PING'] = time()
-                    _this_peer['CALLSIGN'] = _data[8:16]
+                    _this_client['CALLSIGN'] = _data[8:16]
-                    _this_peer['RX_FREQ'] = _data[16:25]
+                    _this_client['RX_FREQ'] = _data[16:25]
-                    _this_peer['TX_FREQ'] =  _data[25:34]
+                    _this_client['TX_FREQ'] =  _data[25:34]
-                    _this_peer['TX_POWER'] = _data[34:36]
+                    _this_client['TX_POWER'] = _data[34:36]
-                    _this_peer['COLORCODE'] = _data[36:38]
+                    _this_client['COLORCODE'] = _data[36:38]
-                    _this_peer['LATITUDE'] = _data[38:46]
+                    _this_client['LATITUDE'] = _data[38:46]
-                    _this_peer['LONGITUDE'] = _data[46:55]
+                    _this_client['LONGITUDE'] = _data[46:55]
-                    _this_peer['HEIGHT'] = _data[55:58]
+                    _this_client['HEIGHT'] = _data[55:58]
-                    _this_peer['LOCATION'] = _data[58:78]
+                    _this_client['LOCATION'] = _data[58:78]
-                    _this_peer['DESCRIPTION'] = _data[78:97]
+                    _this_client['DESCRIPTION'] = _data[78:97]
-                    _this_peer['SLOTS'] = _data[97:98]
+                    _this_client['SLOTS'] = _data[97:98]
-                    _this_peer['URL'] = _data[98:222]
+                    _this_client['URL'] = _data[98:222]
-                    _this_peer['SOFTWARE_ID'] = _data[222:262]
+                    _this_client['SOFTWARE_ID'] = _data[222:262]
-                    _this_peer['PACKAGE_ID'] = _data[262:302]
+                    _this_client['PACKAGE_ID'] = _data[262:302]
 
-                    self.send_peer(_peer_id, 'RPTACK'+_peer_id)
+                    self.send_client(_radio_id, 'RPTACK'+_radio_id)
-                    logger.info('(%s) Peer %s (%s) has sent repeater configuration', self._system, _this_peer['CALLSIGN'], _this_peer['RADIO_ID'])
+                    self._logger.info('(%s) Client %s (%s) has sent repeater configuration', self._system, _this_client['CALLSIGN'], _this_client['RADIO_ID'])
                 else:
-                    self.transport.write('MSTNAK'+_peer_id, _sockaddr)
+                    self.transport.write('MSTNAK'+_radio_id, (_host, _port))
-                    logger.warning('(%s) Peer info from Radio ID that has not logged in: %s', self._system, int_id(_peer_id))
+                    self._logger.warning('(%s) Client info from Radio ID that has not logged in: %s', self._system, int_id(_radio_id))
 
-        elif _command == 'RPTP':    # RPTPing -- peer is pinging us
+        elif _command == 'RPTP':    # RPTPing -- client is pinging us
-                _peer_id = _data[7:11]
+                _radio_id = _data[7:11]
-                if _peer_id in self._peers \
+                if _radio_id in self._clients \
-                            and self._peers[_peer_id]['CONNECTION'] == "YES" \
+                            and self._clients[_radio_id]['CONNECTION'] == "YES" \
-                            and self._peers[_peer_id]['SOCKADDR'] == _sockaddr:
+                            and self._clients[_radio_id]['IP'] == _host \
-                    self._peers[_peer_id]['PINGS_RECEIVED'] += 1
+                            and self._clients[_radio_id]['PORT'] == _port:
-                    self._peers[_peer_id]['LAST_PING'] = time()
+                    self._clients[_radio_id]['LAST_PING'] = time()
-                    self.send_peer(_peer_id, 'MSTPONG'+_peer_id)
+                    self.send_client(_radio_id, 'MSTPONG'+_radio_id)
-                    logger.debug('(%s) Received and answered RPTPING from peer %s (%s)', self._system, self._peers[_peer_id]['CALLSIGN'], int_id(_peer_id))
+                    self._logger.debug('(%s) Received and answered RPTPING from client %s (%s)', self._system, self._clients[_radio_id]['CALLSIGN'], int_id(_radio_id))
                 else:
-                    self.transport.write('MSTNAK'+_peer_id, _sockaddr)
+                    self.transport.write('MSTNAK'+_radio_id, (_host, _port))
-                    logger.warning('(%s) Ping from Radio ID that is not logged in: %s', self._system, int_id(_peer_id))
+                    self._logger.warning('(%s) Client info from Radio ID that has not logged in: %s', self._system, int_id(_radio_id))
 
         else:
-            logger.error('(%s) Unrecognized command. Raw HBP PDU: %s', self._system, ahex(_data))
+            self._logger.error('(%s) Unrecognized command. Raw HBP PDU: %s', self._system, ahex(_data))
         
-    # Aliased in __init__ to datagramReceived if system is a peer
+    # Aliased in __init__ to datagramReceived if system is a client
-    def peer_datagramReceived(self, _data, _sockaddr):
+    def client_datagramReceived(self, _data, (_host, _port)):
         # Keep This Line Commented Unless HEAVILY Debugging!
-        # logger.debug('(%s) RX packet from %s -- %s', self._system, _sockaddr, ahex(_data))
+        # self._logger.debug('(%s) RX packet from %s:%s -- %s', self._system, _host, _port, ahex(_data))
 
         # Validate that we receveived this packet from the master - security check!
-        if self._config['MASTER_SOCKADDR'] == _sockaddr:
+        if self._config['MASTER_IP'] == _host and self._config['MASTER_PORT'] == _port:
             # Extract the command, which is various length, but only 4 significant characters
             _command = _data[:4]
             if   _command == 'DMRD':    # DMRData -- encapsulated DMR data frame
-                _peer_id = _data[11:15]
+                _radio_id = _data[11:15]
-                if self._config['LOOSE'] or _peer_id == self._config['RADIO_ID']: # Validate the Radio_ID unless using loose validation
+                if self._config['LOOSE'] or _radio_id == self._config['RADIO_ID']: # Validate the Radio_ID unless using loose validation
                     _seq = _data[4:5]
                     _rf_src = _data[5:8]
                     _dst_id = _data[8:11]
                     _bits = int_id(_data[15])
                     _slot = 2 if (_bits & 0x80) else 1
-                    #_call_type = 'unit' if (_bits & 0x40) else 'group'
+                    _call_type = 'unit' if (_bits & 0x40) else 'group'
-                    if _bits & 0x40:
-                        _call_type = 'unit'
-                    elif (_bits & 0x23) == 0x23:
-                        _call_type = 'vcsbk'
-                    else:
-                        _call_type = 'group'
                     _frame_type = (_bits & 0x30) >> 4
                     _dtype_vseq = (_bits & 0xF) # data, 1=voice header, 2=voice terminator; voice, 0=burst A ... 5=burst F
                     _stream_id = _data[16:20]
-                    #logger.debug('(%s) DMRD - Sequence: %s, RF Source: %s, Destination ID: %s', self._system, int_id(_seq), int_id(_rf_src), int_id(_dst_id))
+                    #self._logger.debug('(%s) DMRD - Seqence: %s, RF Source: %s, Destination ID: %s', self._system, int_id(_seq), int_id(_rf_src), int_id(_dst_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 WITH STREAM ID %s FROM SUBSCRIBER %s BY GLOBAL ACL', self._system, int_id(_stream_id), int_id(_rf_src))
-                                if _slot == 1:
-                                    self._laststrid1 = _stream_id
-                                else:
-                                    self._laststrid2 = _stream_id
-                            return
-                        if _slot == 1 and not acl_check(_dst_id, self._CONFIG['GLOBAL']['TG1_ACL']):
-                            if self._laststrid1 != _stream_id:
-                                logger.debug('(%s) CALL DROPPED WITH STREAM ID %s ON TGID %s BY GLOBAL TS1 ACL', self._system, int_id(_stream_id), int_id(_dst_id))
-                                self._laststrid1 = _stream_id
-                            return
-                        if _slot == 2 and not acl_check(_dst_id, self._CONFIG['GLOBAL']['TG2_ACL']):
-                            if self._laststrid2 != _stream_id:
-                                logger.debug('(%s) CALL DROPPED WITH STREAM ID %s ON TGID %s BY GLOBAL TS2 ACL', self._system, int_id(_stream_id), int_id(_dst_id))
-                                self._laststrid2 = _stream_id
-                            return
-                    if self._config['USE_ACL']:
-                        if not acl_check(_rf_src, self._config['SUB_ACL']):
-                            if self._laststrid != _stream_id:
-                                logger.debug('(%s) CALL DROPPED WITH STREAM ID %s FROM SUBSCRIBER %s BY SYSTEM ACL', self._system, int_id(_stream_id), int_id(_rf_src))
-                                if _slot == 1:
-                                    self._laststrid1 = _stream_id
-                                else:
-                                    self._laststrid2 = _stream_id
-                            return
-                        if _slot == 1 and not acl_check(_dst_id, self._config['TG1_ACL']):
-                            if self._laststrid1 != _stream_id:
-                                logger.debug('(%s) CALL DROPPED WITH STREAM ID %s ON TGID %s BY SYSTEM TS1 ACL', self._system, int_id(_stream_id), int_id(_dst_id))
-                                self._laststrid1 = _stream_id
-                            return
-                        if _slot == 2 and not acl_check(_dst_id, self._config['TG2_ACL']):
-                            if self._laststrid2 != _stream_id:
-                                logger.debug('(%s) CALL DROPPED WITH STREAM ID %s ON TGID %s BY SYSTEM TS2 ACL', self._system, int_id(_stream_id), int_id(_dst_id))
-                                self._laststrid2 = _stream_id
-                            return
 
+                    # If AMBE audio exporting is configured...
+                    if self._config['EXPORT_AMBE']:
+                        self._ambe.parseAMBE(self._system, _data)
 
                     # Userland actions -- typically this is the function you subclass for an application
-                    self.dmrd_received(_peer_id, _rf_src, _dst_id, _seq, _slot, _call_type, _frame_type, _dtype_vseq, _stream_id, _data)
+                    self.dmrd_received(_radio_id, _rf_src, _dst_id, _seq, _slot, _call_type, _frame_type, _dtype_vseq, _stream_id, _data)
+                else:
+                    if (ord(_data[15]) & 0x2F) == 0x21: # call initiator flag?
+                        self._logger.warning('(%s) Packet received for wrong RADIO_ID.  Got %d should be %d', self._system, int_id(_radio_id), int_id(self._config['RADIO_ID']))
 
             elif _command == 'MSTN':    # Actually MSTNAK -- a NACK from the master
-                _peer_id = _data[6:10]
+                _radio_id = _data[6:10] #
-                if self._config['LOOSE'] or _peer_id == self._config['RADIO_ID']: # Validate the Radio_ID unless using loose validation
+                if self._config['LOOSE'] or _radio_id == self._config['RADIO_ID']: # Validate the Radio_ID unless using loose validation
-                    logger.warning('(%s) MSTNAK Received. Resetting connection to the Master.', self._system)
+                    self._logger.warning('(%s) MSTNAK Received. Resetting connection to the Master.', self._system)
                     self._stats['CONNECTION'] = 'NO' # Disconnect ourselves and re-register
-                    self._stats['CONNECTED'] = time()
+                else:
+                    self._logger.debug('(%s) MSTNAK contained wrong ID - Ignoring', self._system)
 
             elif _command == 'RPTA':    # Actually RPTACK -- an ACK from the master
                 # Depending on the state, an RPTACK means different things, in each clause, we check and/or set the state
                 if self._stats['CONNECTION'] == 'RPTL_SENT': # If we've sent a login request...
                     _login_int32 = _data[6:10]
-                    logger.info('(%s) Repeater Login ACK Received with 32bit ID: %s', self._system, int_id(_login_int32))
+                    self._logger.info('(%s) Repeater Login ACK Received with 32bit ID: %s', self._system, int_id(_login_int32))
                     _pass_hash = sha256(_login_int32+self._config['PASSPHRASE']).hexdigest()
                     _pass_hash = bhex(_pass_hash)
                     self.send_master('RPTK'+self._config['RADIO_ID']+_pass_hash)
                     self._stats['CONNECTION'] = 'AUTHENTICATED'
 
                 elif self._stats['CONNECTION'] == 'AUTHENTICATED': # If we've sent the login challenge...
-                    _peer_id = _data[6:10]
+                    _radio_id = _data[6:10]
-                    if self._config['LOOSE'] or _peer_id == self._config['RADIO_ID']: # Validate the Radio_ID unless using loose validation
+                    if self._config['LOOSE'] or _radio_id == self._config['RADIO_ID']: # Validate the Radio_ID unless using loose validation
-                        logger.info('(%s) Repeater Authentication Accepted', self._system)
+                        self._logger.info('(%s) Repeater Authentication Accepted', self._system)
                         _config_packet =  self._config['RADIO_ID']+\
                                           self._config['CALLSIGN']+\
                                           self._config['RX_FREQ']+\
@@ -615,127 +439,56 @@ class HBSYSTEM(DatagramProtocol):
 
                         self.send_master('RPTC'+_config_packet)
                         self._stats['CONNECTION'] = 'CONFIG-SENT'
-                        logger.info('(%s) Repeater Configuration Sent', self._system)
+                        self._logger.info('(%s) Repeater Configuration Sent', self._system)
                     else:
                         self._stats['CONNECTION'] = 'NO'
-                        logger.error('(%s) Master ACK Contained wrong ID - Connection Reset', self._system)
+                        self._logger.error('(%s) Master ACK Contained wrong ID - Connection Reset', self._system)
 
                 elif self._stats['CONNECTION'] == 'CONFIG-SENT': # If we've sent out configuration to the master
-                    _peer_id = _data[6:10]
+                    _radio_id = _data[6:10]
-                    if self._config['LOOSE'] or _peer_id == self._config['RADIO_ID']: # Validate the Radio_ID unless using loose validation
+                    if self._config['LOOSE'] or _radio_id == self._config['RADIO_ID']: # Validate the Radio_ID unless using loose validation
-                        logger.info('(%s) Repeater Configuration Accepted', self._system)
                         if self._config['OPTIONS']:
                             self.send_master('RPTO'+self._config['RADIO_ID']+self._config['OPTIONS'])
                             self._stats['CONNECTION'] = 'OPTIONS-SENT'
-                            logger.info('(%s) Sent options: (%s)', self._system, self._config['OPTIONS'])
+                            self._logger.info('(%s) Sent options: (%s)', self._system, self._config['OPTIONS'])
                         else:
                             self._stats['CONNECTION'] = 'YES'
-                            self._stats['CONNECTED'] = time()
+                            self._logger.info('(%s) Connection to Master Completed', self._system)
-                            logger.info('(%s) Connection to Master Completed', self._system)
                     else:
                         self._stats['CONNECTION'] = 'NO'
-                        logger.error('(%s) Master ACK Contained wrong ID - Connection Reset', self._system)
+                        self._logger.error('(%s) Master ACK Contained wrong ID - Connection Reset', self._system)
 
                 elif self._stats['CONNECTION'] == 'OPTIONS-SENT': # If we've sent out options to the master
-                    _peer_id = _data[6:10]
+                    _radio_id = _data[6:10]
-                    if self._config['LOOSE'] or _peer_id == self._config['RADIO_ID']: # Validate the Radio_ID unless using loose validation
+                    if self._config['LOOSE'] or _radio_id == self._config['RADIO_ID']: # Validate the Radio_ID unless using loose validation
-                        logger.info('(%s) Repeater Options Accepted', self._system)
+                        self._logger.info('(%s) Repeater Options Accepted', self._system)
                         self._stats['CONNECTION'] = 'YES'
-                        self._stats['CONNECTED'] = time()
+                        self._logger.info('(%s) Connection to Master Completed with options', self._system)
-                        logger.info('(%s) Connection to Master Completed with options', self._system)
                     else:
                         self._stats['CONNECTION'] = 'NO'
-                        logger.error('(%s) Master ACK Contained wrong ID - Connection Reset', self._system)
+                        self._logger.error('(%s) Master ACK Contained wrong ID - Connection Reset', self._system)
 
-            elif _command == 'MSTP':    # Actually MSTPONG -- a reply to RPTPING (send by peer)
+            elif _command == 'MSTP':    # Actually MSTPONG -- a reply to RPTPING (send by client)
-                _peer_id = _data[7:11]
+                _radio_id = _data[7:11]
-                if self._config['LOOSE'] or _peer_id == self._config['RADIO_ID']: # Validate the Radio_ID unless using loose validation
+                if self._config['LOOSE'] or _radio_id == self._config['RADIO_ID']: # Validate the Radio_ID unless using loose validation
                     self._stats['PING_OUTSTANDING'] = False
                     self._stats['NUM_OUTSTANDING'] = 0
                     self._stats['PINGS_ACKD'] += 1
-                    logger.debug('(%s) MSTPONG Received. Pongs Since Connected: %s', self._system, self._stats['PINGS_ACKD'])
+                    self._logger.debug('(%s) MSTPONG Received. Pongs Since Connected: %s', self._system, self._stats['PINGS_ACKD'])
+                else:
+                    self._logger.debug('(%s) MSTPONG contained wrong ID - Ignoring', self._system)
 
             elif _command == 'MSTC':    # Actually MSTCL -- notify us the master is closing down
-                _peer_id = _data[5:9]
+                _radio_id = _data[5:9]
-                if self._config['LOOSE'] or _peer_id == self._config['RADIO_ID']: # Validate the Radio_ID unless using loose validation
+                if self._config['LOOSE'] or _radio_id == self._config['RADIO_ID']: # Validate the Radio_ID unless using loose validation
                     self._stats['CONNECTION'] = 'NO'
-                    logger.info('(%s) MSTCL Recieved', self._system)
+                    self._logger.info('(%s) MSTCL Recieved', self._system)
+                else:
+                    self._logger.debug('(%s) MSTCL contained wrong ID - Ignoring', self._system)
 
             else:
-                logger.error('(%s) Received an invalid command in packet: %s', self._system, ahex(_data))
+                self._logger.error('(%s) Received an invalid command in packet: %s', self._system, ahex(_data))
 
-#
-# Socket-based reporting section
-#
-class report(NetstringReceiver):
-    def __init__(self, factory):
-        self._factory = factory
-
-    def connectionMade(self):
-        self._factory.clients.append(self)
-        logger.info('HBlink reporting client connected: %s', self.transport.getPeer())
-
-    def connectionLost(self, reason):
-        logger.info('HBlink reporting client disconnected: %s', self.transport.getPeer())
-        self._factory.clients.remove(self)
-
-    def stringReceived(self, data):
-        self.process_message(data)
-
-    def process_message(self, _message):
-        opcode = _message[:1]
-        if opcode == REPORT_OPCODES['CONFIG_REQ']:
-            logger.info('HBlink reporting client sent \'CONFIG_REQ\': %s', self.transport.getPeer())
-            self.send_config()
-        else:
-            logger.error('got unknown opcode')
-
-class reportFactory(Factory):
-    def __init__(self, config):
-        self._config = config
-
-    def buildProtocol(self, addr):
-        if (addr.host) in self._config['REPORTS']['REPORT_CLIENTS'] or '*' in self._config['REPORTS']['REPORT_CLIENTS']:
-            logger.debug('Permitting report server connection attempt from: %s:%s', addr.host, addr.port)
-            return report(self)
-        else:
-            logger.error('Invalid report server connection attempt from: %s:%s', addr.host, addr.port)
-            return None
-
-    def send_clients(self, _message):
-        for client in self.clients:
-            client.sendString(_message)
-
-    def send_config(self):
-        serialized = pickle.dumps(self._config['SYSTEMS'], protocol=pickle.HIGHEST_PROTOCOL)
-        self.send_clients(REPORT_OPCODES['CONFIG_SND']+serialized)
-
-
-# ID ALIAS CREATION
-# Download
-def mk_aliases(_config):
-    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')
-
-    return peer_ids, subscriber_ids, talkgroup_ids
 
 #************************************************
 #      MAIN PROGRAM LOOP STARTS HERE
@@ -769,13 +522,12 @@ 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: HBLINK IS TERMINATING WITH SIGNAL %s', str(_signal))
-        hblink_handler(_signal, _frame)
+        hblink_handler(_signal, _frame, logger)
         logger.info('SHUTDOWN: ALL SYSTEM HANDLERS EXECUTED - STOPPING REACTOR')
         reactor.stop()
         
@@ -783,19 +535,11 @@ if __name__ == '__main__':
     for sig in [signal.SIGTERM, signal.SIGINT]:
         signal.signal(sig, sig_handler)
 
-    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 \'HBlink.py\' -- SYSTEM STARTING...')
+    logger.info('HBlink \'HBlink.py\' (c) 2016 N0MJS & the K0USY Group - SYSTEM STARTING...')
     for system in CONFIG['SYSTEMS']:
         if CONFIG['SYSTEMS'][system]['ENABLED']:
-            if CONFIG['SYSTEMS'][system]['MODE'] == 'OPENBRIDGE':
+            systems[system] = HBSYSTEM(system, CONFIG, logger)
-                systems[system] = OPENBRIDGE(system, CONFIG, report_server)
-            else:
-                systems[system] = HBSYSTEM(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])
 

install.sh

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

mk-required

@@ -0,0 +1,10 @@
+  apt-get install python-dev -y
+	apt-get install python-pip -y
+  apt-get install python-twisted -y
+	pip install bitstring
+	pip install bitarray
+
+  cd /opt
+  git clone https://github.com/n0mjs710/dmr_utils.git
+  cd dmr_utils/
+	pip install --upgrade .

reporting_const.py

@@ -1,30 +0,0 @@
-###############################################################################
-#   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',
-    }

sub_acl.py

@@ -0,0 +1,5 @@
+# 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,....'
+ACL = 'DENY:0-2999,4000000-9999999'

systemd/README.md

@@ -1,24 +0,0 @@
-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

@@ -1,21 +0,0 @@
-[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

@@ -1,21 +0,0 @@
-[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

@@ -0,0 +1 @@
+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