2016-12-21 20:55:53 -05:00
#!/usr/bin/env python
#
###############################################################################
# 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
# 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
2017-05-16 14:50:56 -04:00
2017-04-27 16:37:41 -04:00
from twisted . internet . protocol import Factory , Protocol
from twisted . protocols . basic import NetstringReceiver
2016-12-21 20:55:53 -05:00
from twisted . internet import reactor
from twisted . internet import task
2017-05-16 14:50:56 -04:00
2016-12-21 20:55:53 -05:00
from binascii import b2a_hex as ahex
from time import time
from importlib import import_module
2017-05-16 14:50:56 -04:00
import cPickle as pickle
2016-12-21 20:55:53 -05:00
from dmr_utils . utils import hex_str_3 , hex_str_4 , int_id
2017-05-16 14:50:56 -04:00
from dmrlink import IPSC , mk_ipsc_systems , systems , reportFactory , REPORT_OPCODES , build_aliases
2017-05-16 17:55:08 -04:00
from ipsc . ipsc_const import BURST_DATA_TYPE
2016-12-21 20:55:53 -05:00
__author__ = ' Cortney T. Buffington, N0MJS '
__copyright__ = ' Copyright (c) 2013 - 2016 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 '
# Minimum time between different subscribers transmitting on the same TGID
#
TS_CLEAR_TIME = .2
2017-05-16 14:50:56 -04:00
# Declare this here so that we can define functions around it
#
BRIDGES = { }
# Timed loop used for reporting IPSC status
#
# REPORT BASED ON THE TYPE SELECTED IN THE MAIN CONFIG FILE
def config_reports ( _config , _logger , _factory ) :
if _config [ ' REPORTS ' ] [ ' REPORT_NETWORKS ' ] == ' PRINT ' :
def reporting_loop ( _logger ) :
_logger . debug ( ' Periodic Reporting Loop Started (PRINT) ' )
for system in _config [ ' SYSTEMS ' ] :
print_master ( _config , system )
print_peer_list ( _config , system )
reporting = task . LoopingCall ( reporting_loop , _logger )
reporting . start ( _config [ ' REPORTS ' ] [ ' REPORT_INTERVAL ' ] )
report_server = False
elif _config [ ' REPORTS ' ] [ ' REPORT_NETWORKS ' ] == ' NETWORK ' :
def reporting_loop ( _logger , _server ) :
_logger . debug ( ' Periodic Reporting Loop Started (NETWORK) ' )
_server . send_config ( )
_server . send_bridge ( )
_logger . info ( ' DMRlink TCP reporting server starting ' )
report_server = _factory ( _config , _logger )
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 ' ] )
else :
def reporting_loop ( _logger ) :
_logger . debug ( ' Periodic Reporting Loop Started (NULL) ' )
report_server = False
return report_server
2016-12-22 13:53:08 -05:00
# Build the conference bridging structure from the bridge file.
2016-12-21 20:55:53 -05:00
#
2017-03-20 10:27:42 -04:00
def make_bridge_config ( _confbridge_rules ) :
2016-12-21 20:55:53 -05:00
try :
bridge_file = import_module ( _confbridge_rules )
logger . info ( ' Bridge configuration file found and imported ' )
except ImportError :
sys . exit ( ' Bridge configuration file not found or invalid ' )
# Convert integer GROUP ID numbers from the config into hex strings
# we need to send in the actual data packets.
#
for _bridge in bridge_file . BRIDGES :
for _system in bridge_file . BRIDGES [ _bridge ] :
if _system [ ' SYSTEM ' ] not in CONFIG [ ' SYSTEMS ' ] :
sys . exit ( ' ERROR: Conference bridges found for system not configured main configuration ' )
_system [ ' TGID ' ] = hex_str_3 ( _system [ ' TGID ' ] )
for i , e in enumerate ( _system [ ' ON ' ] ) :
_system [ ' ON ' ] [ i ] = hex_str_3 ( _system [ ' ON ' ] [ i ] )
for i , e in enumerate ( _system [ ' OFF ' ] ) :
_system [ ' OFF ' ] [ i ] = hex_str_3 ( _system [ ' OFF ' ] [ i ] )
_system [ ' TIMEOUT ' ] = _system [ ' TIMEOUT ' ] * 60
2017-03-24 09:38:34 -04:00
_system [ ' TIMER ' ] = time ( )
2016-12-21 20:55:53 -05:00
2017-03-20 10:27:42 -04:00
return { ' BRIDGE_CONF ' : bridge_file . BRIDGE_CONF , ' BRIDGES ' : bridge_file . BRIDGES }
2016-12-21 20:55:53 -05:00
# 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
2017-05-01 13:20:34 -04:00
2016-12-21 20:55:53 -05:00
# Run this every minute for rule timer updates
def rule_timer_loop ( ) :
logger . info ( ' (ALL IPSC SYSTEMS) Rule timer loop started ' )
_now = time ( )
for _bridge in BRIDGES :
for _system in BRIDGES [ _bridge ] :
if _system [ ' TO_TYPE ' ] == ' ON ' :
if _system [ ' ACTIVE ' ] == True :
if _system [ ' TIMER ' ] < _now :
_system [ ' ACTIVE ' ] = False
logger . info ( ' Conference Bridge TIMEOUT: DEACTIVATE System: %s , Bridge: %s , TS: %s , TGID: %s ' , _system [ ' SYSTEM ' ] , _bridge , _system [ ' TS ' ] , int_id ( _system [ ' TGID ' ] ) )
else :
timeout_in = _system [ ' TIMER ' ] - _now
logger . info ( ' Conference Bridge ACTIVE (ON timer running): System: %s Bridge: %s , TS: %s , TGID: %s , Timeout in: %s s, ' , _system [ ' SYSTEM ' ] , _bridge , _system [ ' TS ' ] , int_id ( _system [ ' TGID ' ] ) , timeout_in )
elif _system [ ' ACTIVE ' ] == False :
logger . debug ( ' Conference Bridge INACTIVE (no change): System: %s Bridge: %s , TS: %s , TGID: %s ' , _system [ ' SYSTEM ' ] , _bridge , _system [ ' TS ' ] , int_id ( _system [ ' TGID ' ] ) )
elif _system [ ' TO_TYPE ' ] == ' OFF ' :
if _system [ ' ACTIVE ' ] == False :
if _system [ ' TIMER ' ] < _now :
_system [ ' ACTIVE ' ] = True
logger . info ( ' Conference Bridge TIMEOUT: ACTIVATE System: %s , Bridge: %s , TS: %s , TGID: %s ' , _system [ ' SYSTEM ' ] , _bridge , _system [ ' TS ' ] , int_id ( _system [ ' TGID ' ] ) )
else :
timeout_in = _system [ ' TIMER ' ] - _now
logger . info ( ' Conference Bridge INACTIVE (OFF timer running): System: %s Bridge: %s , TS: %s , TGID: %s , Timeout in: %s s, ' , _system [ ' SYSTEM ' ] , _bridge , _system [ ' TS ' ] , int_id ( _system [ ' TGID ' ] ) , timeout_in )
elif _system [ ' ACTIVE ' ] == True :
logger . debug ( ' Conference Bridge ACTIVE (no change): System: %s Bridge: %s , TS: %s , TGID: %s ' , _system [ ' SYSTEM ' ] , _bridge , _system [ ' TS ' ] , int_id ( _system [ ' TGID ' ] ) )
else :
logger . debug ( ' Conference Bridge NO ACTION: System: %s , Bridge: %s , TS: %s , TGID: %s ' , _system [ ' SYSTEM ' ] , _bridge , _system [ ' TS ' ] , int_id ( _system [ ' TGID ' ] ) )
2017-05-17 21:56:12 -04:00
if BRIDGE_CONF [ ' REPORT ' ] == ' network ' :
2017-04-27 16:37:41 -04:00
report_server . send_clients ( ' bridge updated ' )
2017-03-20 10:27:42 -04:00
2016-12-21 20:55:53 -05:00
class confbridgeIPSC ( IPSC ) :
2017-05-15 15:31:34 -04:00
def __init__ ( self , _name , _config , _logger , _report ) :
IPSC . __init__ ( self , _name , _config , _logger , _report )
2016-12-21 20:55:53 -05:00
self . STATUS = {
1 : { ' RX_TGID ' : ' \x00 ' , ' TX_TGID ' : ' \x00 ' , ' RX_TIME ' : 0 , ' TX_TIME ' : 0 , ' RX_SRC_SUB ' : ' \x00 ' , ' TX_SRC_SUB ' : ' \x00 ' } ,
2 : { ' RX_TGID ' : ' \x00 ' , ' TX_TGID ' : ' \x00 ' , ' RX_TIME ' : 0 , ' TX_TIME ' : 0 , ' RX_SRC_SUB ' : ' \x00 ' , ' TX_SRC_SUB ' : ' \x00 ' }
}
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 ]
now = time ( ) # Mark packet arrival time -- we'll need this for call contention handling
for _bridge in BRIDGES :
for _system in BRIDGES [ _bridge ] :
if ( _system [ ' SYSTEM ' ] == self . _system and _system [ ' TGID ' ] == _dst_group and _system [ ' TS ' ] == _ts and _system [ ' ACTIVE ' ] == True ) :
for _target in BRIDGES [ _bridge ] :
2016-12-21 22:00:54 -05:00
if _target [ ' SYSTEM ' ] != self . _system :
if _target [ ' ACTIVE ' ] :
_target_status = systems [ _target [ ' SYSTEM ' ] ] . STATUS
_target_system = self . _CONFIG [ ' SYSTEMS ' ] [ _target [ ' SYSTEM ' ] ]
2016-12-21 20:55:53 -05:00
2016-12-21 22:00:54 -05:00
# 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 IPSC, but it has been less than Group Hangtime
# From a different group than last TX to this IPSC, but it has been less than Group Hangtime
# From the same group as the last RX from this IPSC, but from a different subscriber, and it has been less than TS Clear Time
# From the same group as the last TX to this IPSC, but from a different subscriber, and it has been less than TS Clear Time
# 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 ( ( now - _target_status [ _target [ ' TS ' ] ] [ ' RX_TIME ' ] ) < _target_system [ ' LOCAL ' ] [ ' GROUP_HANGTIME ' ] ) ) :
if _burst_data_type == BURST_DATA_TYPE [ ' VOICE_HEAD ' ] :
2017-01-16 10:54:09 -05:00
self . _logger . info ( ' ( %s ) Call not bridged to TGID %s , target active or in group hangtime: IPSC: %s , TS: %s , TGID: %s ' , self . _system , int_id ( _target [ ' TGID ' ] ) , _target [ ' SYSTEM ' ] , _target [ ' TS ' ] , int_id ( _target_status [ _target [ ' TS ' ] ] [ ' RX_TGID ' ] ) )
2017-03-22 22:14:35 -04:00
continue
2016-12-21 22:00:54 -05:00
if ( ( _target [ ' TGID ' ] != _target_status [ _target [ ' TS ' ] ] [ ' TX_TGID ' ] ) and ( ( now - _target_status [ _target [ ' TS ' ] ] [ ' TX_TIME ' ] ) < _target_system [ ' LOCAL ' ] [ ' GROUP_HANGTIME ' ] ) ) :
if _burst_data_type == BURST_DATA_TYPE [ ' VOICE_HEAD ' ] :
self . _logger . info ( ' ( %s ) Call not bridged to TGID %s , target in group hangtime: IPSC: %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 ( ( now - _target_status [ _target [ ' TS ' ] ] [ ' RX_TIME ' ] ) < TS_CLEAR_TIME ) :
if _burst_data_type == BURST_DATA_TYPE [ ' VOICE_HEAD ' ] :
2017-04-14 08:23:18 -04:00
self . _logger . info ( ' ( %s ) Call not bridged to TGID %s , matching call already active on target: IPSC: %s , TS: %s , TGID: %s ' , self . _system , int_id ( _target [ ' TGID ' ] ) , _target [ ' SYSTEM ' ] , _target [ ' TS ' ] , int_id ( _target_status [ _target [ ' TS ' ] ] [ ' RX_TGID ' ] ) )
2016-12-21 22:00:54 -05:00
continue
if ( _target [ ' TGID ' ] == _target_status [ _target [ ' TS ' ] ] [ ' TX_TGID ' ] ) and ( _src_sub != _target_status [ _target [ ' TS ' ] ] [ ' TX_SRC_SUB ' ] ) and ( ( now - _target_status [ _target [ ' TS ' ] ] [ ' TX_TIME ' ] ) < TS_CLEAR_TIME ) :
if _burst_data_type == BURST_DATA_TYPE [ ' VOICE_HEAD ' ] :
self . _logger . info ( ' ( %s ) Call not bridged for subscriber %s , call bridge in progress on target: IPSC: %s , TS: %s , TGID: %s SUB: %s ' , self . _system , int_id ( _src_sub ) , _target [ ' SYSTEM ' ] , _target [ ' TGID ' ] , int_id ( _target_status [ _target [ ' TS ' ] ] [ ' TX_TGID ' ] ) , int_id ( _target_status [ _target [ ' TS ' ] ] [ ' TX_SRC_SUB ' ] ) )
continue
#
# END CONTENTION HANDLING
#
2016-12-21 20:55:53 -05:00
2016-12-21 22:00:54 -05:00
#
# BEGIN FRAME FORWARDING
2017-03-22 22:14:35 -04:00
#
# Make a copy of the payload
2016-12-21 22:00:54 -05:00
_tmp_data = _data
2016-12-21 20:55:53 -05:00
2016-12-21 22:00:54 -05:00
# Re-Write the IPSC SRC to match the target network's ID
_tmp_data = _tmp_data . replace ( _peerid , _target_system [ ' LOCAL ' ] [ ' RADIO_ID ' ] )
2016-12-21 20:55:53 -05:00
2016-12-21 22:00:54 -05:00
# Re-Write the destination Group ID
_tmp_data = _tmp_data . replace ( _dst_group , _target [ ' TGID ' ] )
2016-12-21 20:55:53 -05:00
2016-12-21 22:00:54 -05:00
# Re-Write IPSC timeslot value
_call_info = int_id ( _data [ 17 : 18 ] )
2016-12-21 20:55:53 -05:00
if _target [ ' TS ' ] == 1 :
2016-12-21 22:00:54 -05:00
_call_info & = ~ ( 1 << 5 )
elif _target [ ' TS ' ] == 2 :
_call_info | = 1 << 5
_call_info = chr ( _call_info )
_tmp_data = _tmp_data [ : 17 ] + _call_info + _tmp_data [ 18 : ]
# Re-Write DMR timeslot value
# Determine if the slot is present, so we can translate if need be
if _burst_data_type == BURST_DATA_TYPE [ ' SLOT1_VOICE ' ] or _burst_data_type == BURST_DATA_TYPE [ ' SLOT2_VOICE ' ] :
_slot_valid = True
else :
_slot_valid = False
# Re-Write timeslot if necessary...
if _slot_valid :
if _target [ ' TS ' ] == 1 :
_burst_data_type = BURST_DATA_TYPE [ ' SLOT1_VOICE ' ]
elif _target [ ' TS ' ] == 1 :
_burst_data_type = BURST_DATA_TYPE [ ' SLOT2_VOICE ' ]
_tmp_data = _tmp_data [ : 30 ] + _burst_data_type + _tmp_data [ 31 : ]
2016-12-21 20:55:53 -05:00
2016-12-21 22:00:54 -05:00
# Send the packet to all peers in the target IPSC
systems [ _target [ ' SYSTEM ' ] ] . send_to_ipsc ( _tmp_data )
#
# END FRAME FORWARDING
#
2016-12-21 20:55:53 -05:00
2016-12-21 22:00:54 -05:00
# Set values for the contention handler to test next time there is a frame to forward
_target_status [ _target [ ' TS ' ] ] [ ' TX_TGID ' ] = _target [ ' TGID ' ]
_target_status [ _target [ ' TS ' ] ] [ ' TX_TIME ' ] = now
_target_status [ _target [ ' TS ' ] ] [ ' TX_SRC_SUB ' ] = _src_sub
2016-12-21 20:55:53 -05:00
# Mark the group and time that a packet was recieved for the contention handler to use later
self . STATUS [ _ts ] [ ' RX_TGID ' ] = _dst_group
self . STATUS [ _ts ] [ ' RX_TIME ' ] = now
#
# BEGIN IN-BAND SIGNALING BASED ON TGID & VOICE TERMINATOR FRAME
#
# Activate/Deactivate rules based on group voice activity -- PTT or UA for you c-Bridge dorks.
# This will ONLY work for symmetrical rules!!!
# Action happens on key up
if _burst_data_type == BURST_DATA_TYPE [ ' VOICE_HEAD ' ] :
2017-05-17 16:22:24 -04:00
if self . last_seq_id != _seq_id or ( self . call_start + TS_CLEAR_TIME ) < now :
2016-12-21 20:55:53 -05:00
self . last_seq_id = _seq_id
2017-05-17 16:22:24 -04:00
self . call_start = now
2016-12-21 20:55:53 -05:00
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 ) )
2017-05-15 15:31:34 -04:00
if self . _CONFIG [ ' REPORTS ' ] [ ' REPORT_NETWORKS ' ] == ' NETWORK ' :
2017-11-07 09:37:11 -05:00
self . _report . send_bridgeEvent ( ' GROUP VOICE,START, {} , {} , {} , {} , {} , {} ' . format ( self . _system , int_id ( _seq_id ) , int_id ( _peerid ) , int_id ( _src_sub ) , _ts , int_id ( _dst_group ) ) )
2017-05-15 15:31:34 -04:00
2016-12-21 20:55:53 -05:00
# Action happens on un-key
if _burst_data_type == BURST_DATA_TYPE [ ' VOICE_TERM ' ] :
if self . last_seq_id == _seq_id :
2017-05-17 16:22:24 -04:00
self . call_duration = now - self . call_start
2017-05-17 16:31:57 -04:00
self . _logger . info ( ' ( %s ) GROUP VOICE END: CallID: %s PEER: %s , SUB: %s , TS: %s , TGID: %s Duration: %.2f s ' , self . _system , int_id ( _seq_id ) , int_id ( _peerid ) , int_id ( _src_sub ) , _ts , int_id ( _dst_group ) , self . call_duration )
2017-05-15 15:31:34 -04:00
if self . _CONFIG [ ' REPORTS ' ] [ ' REPORT_NETWORKS ' ] == ' NETWORK ' :
2017-11-07 09:37:11 -05:00
self . _report . send_bridgeEvent ( ' GROUP VOICE,END, {} , {} , {} , {} , {} , {} , {:.2f} ' . format ( self . _system , int_id ( _seq_id ) , int_id ( _peerid ) , int_id ( _src_sub ) , _ts , int_id ( _dst_group ) , self . call_duration ) )
2016-12-21 20:55:53 -05:00
else :
2017-05-15 15:31:34 -04:00
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 self . _CONFIG [ ' REPORTS ' ] [ ' REPORT_NETWORKS ' ] == ' NETWORK ' :
2017-11-07 09:37:11 -05:00
self . _report . send_bridgeEvent ( ' GROUP VOICE,UNMATCHED END, {} , {} , {} , {} , {} , {} ' . format ( self . _system , int_id ( _seq_id ) , int_id ( _peerid ) , int_id ( _src_sub ) , _ts , int_id ( _dst_group ) ) )
2017-03-22 22:14:35 -04:00
2016-12-21 20:55:53 -05:00
# Iterate the rules dictionary
for _bridge in BRIDGES :
for _system in BRIDGES [ _bridge ] :
if _system [ ' SYSTEM ' ] == self . _system :
2017-03-22 22:14:35 -04:00
2016-12-21 20:55:53 -05:00
# TGID matches an ACTIVATION trigger
if _dst_group in _system [ ' ON ' ] :
# Set the matching rule as ACTIVE
2017-03-22 22:14:35 -04:00
if _system [ ' ACTIVE ' ] == False :
_system [ ' ACTIVE ' ] = True
self . _logger . info ( ' ( %s ) Bridge: %s , connection changed to state: %s ' , self . _system , _bridge , _system [ ' ACTIVE ' ] )
2017-03-24 09:51:48 -04:00
# Cancel the timer if we've enabled an "OFF" type timeout
if _system [ ' TO_TYPE ' ] == ' OFF ' :
_system [ ' TIMER ' ] = now
self . _logger . info ( ' ( %s ) Bridge: %s set to " OFF " with an on timer rule: timeout timer cancelled ' , self . _system , _bridge )
2017-03-22 22:14:35 -04:00
# Reset the timer for the rule
if _system [ ' ACTIVE ' ] == True and _system [ ' TO_TYPE ' ] == ' ON ' :
_system [ ' TIMER ' ] = now + _system [ ' TIMEOUT ' ]
self . _logger . info ( ' ( %s ) Bridge: %s , timeout timer reset to: %s ' , self . _system , _bridge , _system [ ' TIMER ' ] - now )
2016-12-21 20:55:53 -05:00
# TGID matches an DE-ACTIVATION trigger
if _dst_group in _system [ ' OFF ' ] :
# Set the matching rule as ACTIVE
2017-03-22 22:14:35 -04:00
if _system [ ' ACTIVE ' ] == True :
_system [ ' ACTIVE ' ] = False
self . _logger . info ( ' ( %s ) Bridge: %s , connection changed to state: %s ' , self . _system , _bridge , _system [ ' ACTIVE ' ] )
2017-03-24 09:51:48 -04:00
# Cancel the timer if we've enabled an "ON" type timeout
if _system [ ' TO_TYPE ' ] == ' ON ' :
_system [ ' TIMER ' ] = now
self . _logger . info ( ' ( %s ) Bridge: %s set to ON with and " OFF " timer rule: timeout timer cancelled ' , self . _system , _bridge )
2017-03-22 22:14:35 -04:00
# Reset tge timer for the rule
if _system [ ' ACTIVE ' ] == False and _system [ ' TO_TYPE ' ] == ' OFF ' :
_system [ ' TIMER ' ] = now + _system [ ' TIMEOUT ' ]
self . _logger . info ( ' ( %s ) Bridge: %s , timeout timer reset to: %s ' , self . _system , _bridge , _system [ ' TIMER ' ] - now )
2017-03-24 09:44:00 -04:00
# Cancel the timer if we've enabled an "ON" type timeout
if _system [ ' ACTIVE ' ] == True and _system [ ' TO_TYPE ' ] == ' ON ' :
_system [ ' TIMER ' ] = now
self . _logger . info ( ' ( %s ) Bridge: %s set to ON with and " OFF " timer rule: timeout timer cancelled ' , self . _system , _bridge )
2017-03-22 22:14:35 -04:00
#
2016-12-21 20:55:53 -05:00
# END IN-BAND SIGNALLING
#
2017-05-16 14:50:56 -04:00
class confbridgeReportFactory ( reportFactory ) :
2017-04-27 16:37:41 -04:00
2017-05-16 14:50:56 -04:00
def send_bridge ( self ) :
serialized = pickle . dumps ( BRIDGES , protocol = pickle . HIGHEST_PROTOCOL )
2017-05-15 15:31:34 -04:00
self . send_clients ( REPORT_OPCODES [ ' BRIDGE_SND ' ] + serialized )
2017-05-01 13:20:34 -04:00
2017-05-15 15:31:34 -04:00
def send_bridgeEvent ( self , _data ) :
self . send_clients ( REPORT_OPCODES [ ' BRDG_EVENT ' ] + _data )
2017-05-16 14:50:56 -04:00
2017-03-22 22:14:35 -04:00
if __name__ == ' __main__ ' :
2017-05-15 16:29:16 -04:00
import argparse
2017-05-16 14:50:56 -04:00
import sys
2017-05-15 16:29:16 -04:00
import os
import signal
2017-05-16 14:50:56 -04:00
2017-05-16 17:55:08 -04:00
from ipsc . dmrlink_config import build_config
from ipsc . dmrlink_log import config_logging
2017-05-16 14:50:56 -04:00
2016-12-21 20:55:53 -05:00
# 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) ' )
2017-04-26 15:51:30 -04:00
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. ' )
2016-12-21 20:55:53 -05:00
cli_args = parser . parse_args ( )
if not cli_args . CFG_FILE :
cli_args . CFG_FILE = os . path . dirname ( os . path . abspath ( __file__ ) ) + ' /dmrlink.cfg '
2017-05-16 14:50:56 -04:00
2016-12-21 20:55:53 -05:00
# Call the external routine to build the configuration dictionary
2017-05-15 16:29:16 -04:00
CONFIG = build_config ( cli_args . CFG_FILE )
2017-05-16 14:50:56 -04:00
2016-12-21 20:55:53 -05:00
# Call the external routing to start the system logger
2017-04-26 15:51:30 -04:00
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
2017-05-15 16:29:16 -04:00
logger = config_logging ( CONFIG [ ' LOGGER ' ] )
2017-05-16 14:50:56 -04:00
logger . info ( ' DMRlink \' dmrlink.py \' (c) 2013 - 2015 N0MJS & the K0USY Group - SYSTEM STARTING... ' )
2016-12-21 20:55:53 -05:00
2017-05-16 14:50:56 -04:00
# Set signal handers so that we can gracefully exit if need be
2016-12-21 20:55:53 -05:00
def sig_handler ( _signal , _frame ) :
logger . info ( ' *** DMRLINK IS TERMINATING WITH SIGNAL %s *** ' , str ( _signal ) )
for system in systems :
2017-05-16 14:50:56 -04:00
systems [ system ] . de_register_self ( )
2016-12-21 20:55:53 -05:00
reactor . stop ( )
2017-05-15 16:29:16 -04:00
2016-12-21 20:55:53 -05:00
for sig in [ signal . SIGTERM , signal . SIGINT , signal . SIGQUIT ] :
signal . signal ( sig , sig_handler )
2017-05-16 14:50:56 -04:00
# INITIALIZE THE REPORTING LOOP
report_server = config_reports ( CONFIG , logger , confbridgeReportFactory )
2016-12-21 20:55:53 -05:00
2017-05-16 14:50:56 -04:00
# 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 , confbridgeIPSC , report_server )
# CONFBRIDGE.PY SPECIFIC ITEMS GO HERE:
2016-12-21 20:55:53 -05:00
2017-03-20 10:27:42 -04:00
# Build the routing rules and other configuration
CONFIG_DICT = make_bridge_config ( ' confbridge_rules ' )
BRIDGE_CONF = CONFIG_DICT [ ' BRIDGE_CONF ' ]
BRIDGES = CONFIG_DICT [ ' BRIDGES ' ]
2016-12-21 20:55:53 -05:00
# Build the Access Control List
ACL = build_acl ( ' sub_acl ' )
2017-04-27 16:37:41 -04:00
2017-05-16 14:50:56 -04:00
# Initialize the rule timer loop
rule_timer = task . LoopingCall ( rule_timer_loop )
rule_timer . start ( 60 )
# INITIALIZATION COMPLETE -- START THE REACTOR
2017-03-22 22:14:35 -04:00
reactor . run ( )