From 01916c3197a771c1d331226d83c880a599e07b81 Mon Sep 17 00:00:00 2001 From: Cort Buffington Date: Wed, 17 May 2017 08:30:59 -0500 Subject: [PATCH] Dumb forwarder --- proxy.py | 232 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 232 insertions(+) create mode 100755 proxy.py diff --git a/proxy.py b/proxy.py new file mode 100755 index 0000000..53f9f06 --- /dev/null +++ b/proxy.py @@ -0,0 +1,232 @@ +#!/usr/bin/env python +# +############################################################################### +# Copyright (C) 2016 Cortney T. Buffington, N0MJS +# +# 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 +############################################################################### + +# This is a sample application to bridge traffic between IPSC systems. it uses +# one required (bridge_rules.py) and one optional (known_bridges.py) additional +# configuration files. Both files have their own documentation for use. +# +# "bridge_rules" contains the IPSC network, Timeslot and TGID matching rules to +# determine which voice calls are bridged between IPSC systems and which are +# not. +# +# "known_bridges" contains DMR radio ID numbers of known bridges. This file is +# used when you want bridge.py to be "polite" or serve as a backup bridge. If +# a known bridge exists in either a source OR target IPSC network, then no +# bridging between those IPSC systems will take place. This behavior is +# dynamic and updates each keep-alive interval (main configuration file). +# For faster failover, configure a short keep-alive time and a low number of +# missed keep-alives before timout. I recommend 5 sec keep-alive and 3 missed. +# That gives a worst-case scenario of 15 seconds to fail over. Recovery will +# typically happen with a single "blip" in the transmission up to about 5 +# seconds. +# +# While this file is listed as Beta status, K0USY Group depends on this code +# for the bridigng of it's many repeaters. We consider it reliable, but you +# get what you pay for... as usual, no guarantees. +# +# Use to make test strings: #print('PKT:', "\\x".join("{:02x}".format(ord(c)) for c in _data)) + +from __future__ import print_function +from twisted.internet import reactor +from twisted.internet import task +from binascii import b2a_hex as ahex +from time import time +from importlib import import_module + +import sys + +from dmr_utils.utils import hex_str_3, hex_str_4, int_id + +from dmrlink import IPSC, mk_ipsc_systems, systems, reportFactory, REPORT_OPCODES, build_aliases, config_reports +from ipsc.ipsc_const import BURST_DATA_TYPE + + +__author__ = 'Cortney T. Buffington, N0MJS' +__copyright__ = 'Copyright (c) 2017 Cortney T. Buffington, N0MJS and the K0USY Group' +__credits__ = 'Adam Fast, KC0YLK; Dave Kierzkowski, KD8EYF; Steve Zingman, N4IRS; Mike Zingman, N4IRR' +__license__ = 'GNU GPLv3' +__maintainer__ = 'Cort Buffington, N0MJS' +__email__ = 'n0mjs@me.com' + + +# Import subscriber ACL +# ACL may be a single list of subscriber IDs +# Global action is to allow or deny them. Multiple lists with different actions and ranges +# are not yet implemented. +def build_acl(_sub_acl): + try: + acl_file = import_module(_sub_acl) + for i, e in enumerate(acl_file.ACL): + acl_file.ACL[i] = hex_str_3(acl_file.ACL[i]) + logger.info('ACL file found and ACL entries imported') + ACL_ACTION = acl_file.ACL_ACTION + ACL = acl_file.ACL_ACTION + except ImportError: + logger.info('ACL file not found or invalid - all subscriber IDs are valid') + ACL_ACTION = 'NONE' + ACL = [] + + # Depending on which type of ACL is used (PERMIT, DENY... or there isn't one) + # define a differnet function to be used to check the ACL + global allow_sub + if ACL_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 + + +class proxyIPSC(IPSC): + def __init__(self, _name, _config, _logger, report): + IPSC.__init__(self, _name, _config, _logger, report) + + self.last_seq_id = '\x00' + self.call_start = 0 + + #************************************************ + # CALLBACK FUNCTIONS FOR USER PACKET TYPES + #************************************************ + # + def group_voice(self, _src_sub, _dst_group, _ts, _end, _peerid, _data): + # Check for ACL match, and return if the subscriber is not allowed + if allow_sub(_src_sub) == False: + self._logger.warning('(%s) Group Voice Packet ***REJECTED BY ACL*** From: %s, IPSC Peer %s, Destination %s', self._system, int_id(_src_sub), int_id(_peerid), int_id(_dst_group)) + return + + # Process the packet + self._logger.debug('(%s) Group Voice Packet Received From: %s, IPSC Peer %s, Destination %s', self._system, int_id(_src_sub), int_id(_peerid), int_id(_dst_group)) + _burst_data_type = _data[30] # Determine the type of voice packet this is (see top of file for possible types) + _seq_id = _data[5] + + for system in systems: + if system != self._system: + # + # BEGIN FRAME FORWARDING + # + # Make a copy of the payload + _tmp_data = _data + + # Re-Write the IPSC SRC to match the target network's ID + _tmp_data = _tmp_data.replace(_peerid, self._CONFIG['SYSTEMS'][system]['LOCAL']['RADIO_ID']) + + # Send the packet to all peers in the target IPSC + systems[system].send_to_ipsc(_tmp_data) + # + # END FRAME FORWARDING + # + + # + # BEGIN IN-BAND SIGNALING BASED ON TGID & VOICE TERMINATOR FRAME + # + + # Action happens on key up + if _burst_data_type == BURST_DATA_TYPE['VOICE_HEAD']: + if self.last_seq_id != _seq_id: + self.last_seq_id = _seq_id + self.call_start = time() + self._logger.info('(%s) GROUP VOICE START: CallID: %s PEER: %s, SUB: %s, TS: %s, TGID: %s', self._system, int_id(_seq_id), int_id(_peerid), int_id(_src_sub), _ts, int_id(_dst_group)) + + # Action happens on un-key + if _burst_data_type == BURST_DATA_TYPE['VOICE_TERM']: + if self.last_seq_id == _seq_id: + self.call_duration = time() - self.call_start + self._logger.info('(%s) GROUP VOICE END: CallID: %s PEER: %s, SUB: %s, TS: %s, TGID: %s Duration: %.2fs', self._system, int_id(_seq_id), int_id(_peerid), int_id(_src_sub), _ts, int_id(_dst_group), self.call_duration) + else: + self._logger.warning('(%s) GROUP VOICE END WITHOUT MATCHING START: CallID: %s PEER: %s, SUB: %s, TS: %s, TGID: %s', self._system, int_id(_seq_id), int_id(_peerid), int_id(_src_sub), _ts, int_id(_dst_group),) + + +if __name__ == '__main__': + import argparse + import sys + import os + import signal + + from ipsc.dmrlink_config import build_config + from ipsc.dmrlink_log import config_logging + + # 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 + parser = argparse.ArgumentParser() + parser.add_argument('-c', '--config', action='store', dest='CFG_FILE', help='/full/path/to/config.file (usually dmrlink.cfg)') + parser.add_argument('-ll', '--log_level', action='store', dest='LOG_LEVEL', help='Override config file logging level.') + parser.add_argument('-lh', '--log_handle', action='store', dest='LOG_HANDLERS', help='Override config file logging handler.') + cli_args = parser.parse_args() + + if not cli_args.CFG_FILE: + cli_args.CFG_FILE = os.path.dirname(os.path.abspath(__file__))+'/dmrlink.cfg' + + # Call the external routine to build the configuration dictionary + CONFIG = build_config(cli_args.CFG_FILE) + + # Call the external routing to start the system logger + if cli_args.LOG_LEVEL: + CONFIG['LOGGER']['LOG_LEVEL'] = cli_args.LOG_LEVEL + if cli_args.LOG_HANDLERS: + CONFIG['LOGGER']['LOG_HANDLERS'] = cli_args.LOG_HANDLERS + logger = config_logging(CONFIG['LOGGER']) + logger.info('DMRlink \'dmrlink.py\' (c) 2013 - 2015 N0MJS & the K0USY Group - SYSTEM STARTING...') + + # Set signal handers so that we can gracefully exit if need be + def sig_handler(_signal, _frame): + logger.info('*** DMRLINK IS TERMINATING WITH SIGNAL %s ***', str(_signal)) + for system in systems: + systems[system].de_register_self() + reactor.stop() + + for sig in [signal.SIGTERM, signal.SIGINT, signal.SIGQUIT]: + signal.signal(sig, sig_handler) + + + + # PROXY.PY SPECIFIC ITEMS GO HERE: + + # Build the Access Control List + ACL = build_acl('sub_acl') + + + # MAIN INITIALIZATION ITEMS HERE + + # INITIALIZE THE REPORTING LOOP + report_server = config_reports(CONFIG, logger, reportFactory) + + # Build ID Aliases + peer_ids, subscriber_ids, talkgroup_ids, local_ids = build_aliases(CONFIG, logger) + + # INITIALIZE AN IPSC OBJECT (SELF SUSTAINING) FOR EACH CONFIGURED IPSC + systems = mk_ipsc_systems(CONFIG, logger, systems, proxyIPSC, report_server) + + + + # INITIALIZATION COMPLETE -- START THE REACTOR + reactor.run()