ShaYmez/hbnet
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

working rules download, fixed XLX stuff

Browse Source
This commit is contained in:
KF7EEL 2021-06-15 12:28:44 -07:00
parent 3fd29ab75c
commit 59ac3a693e
4 changed files with 432 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

129
bridge.py
View File

@ -152,15 +152,38 @@ def download_config(L_CONFIG_FILE, cli_file):
if iterate_config[i]['MODE'] == 'MASTER' or iterate_config[i]['MODE'] == 'PROXY': if iterate_config[i]['MODE'] == 'MASTER' or iterate_config[i]['MODE'] == 'PROXY':
corrected_config['SYSTEMS'][i]['TG1_ACL'] = config.acl_build(iterate_config[i]['TG1_ACL'], 16776415) corrected_config['SYSTEMS'][i]['TG1_ACL'] = config.acl_build(iterate_config[i]['TG1_ACL'], 16776415)
corrected_config['SYSTEMS'][i]['TG2_ACL'] = config.acl_build(iterate_config[i]['TG2_ACL'], 16776415) corrected_config['SYSTEMS'][i]['TG2_ACL'] = config.acl_build(iterate_config[i]['TG2_ACL'], 16776415)
corrected_config['SYSTEMS'][i]['PASSPHRASE'] = bytes(iterate_config[i]['PASSPHRASE'], 'utf-8')
if iterate_config[i]['MODE'] == 'OPENBRIDGE': if iterate_config[i]['MODE'] == 'OPENBRIDGE':
corrected_config['SYSTEMS'][i]['NETWORK_ID'] = int(iterate_config[i]['NETWORK_ID']).to_bytes(4, 'big') corrected_config['SYSTEMS'][i]['NETWORK_ID'] = int(iterate_config[i]['NETWORK_ID']).to_bytes(4, 'big')
corrected_config['SYSTEMS'][i]['PASSPHRASE'] = bytes(iterate_config[i]['PASSPHRASE'].ljust(20,'\x00')[:20], 'utf-8')
if iterate_config[i]['MODE'] == 'PEER' or iterate_config[i]['MODE'] == 'XLXPEER': if iterate_config[i]['MODE'] == 'PEER' or iterate_config[i]['MODE'] == 'XLXPEER':
corrected_config['SYSTEMS'][i]['RADIO_ID'] = int(iterate_config[i]['RADIO_ID']).to_bytes(4, 'big') corrected_config['SYSTEMS'][i]['RADIO_ID'] = int(iterate_config[i]['RADIO_ID']).to_bytes(4, 'big')
corrected_config['SYSTEMS'][i]['TG1_ACL'] = config.acl_build(iterate_config[i]['TG1_ACL'], 16776415) corrected_config['SYSTEMS'][i]['TG1_ACL'] = config.acl_build(iterate_config[i]['TG1_ACL'], 16776415)
corrected_config['SYSTEMS'][i]['TG2_ACL'] = config.acl_build(iterate_config[i]['TG2_ACL'], 16776415) corrected_config['SYSTEMS'][i]['TG2_ACL'] = config.acl_build(iterate_config[i]['TG2_ACL'], 16776415)
corrected_config['SYSTEMS'][i]['MASTER_SOCKADDR'] = tuple(iterate_config[i]['MASTER_SOCKADDR']) corrected_config['SYSTEMS'][i]['MASTER_SOCKADDR'] = tuple(iterate_config[i]['MASTER_SOCKADDR'])
corrected_config['SYSTEMS'][i]['SOCK_ADDR'] = tuple(iterate_config[i]['SOCK_ADDR']) corrected_config['SYSTEMS'][i]['SOCK_ADDR'] = tuple(iterate_config[i]['SOCK_ADDR'])
if iterate_config[i]['MODE'] == 'PEER': corrected_config['SYSTEMS'][i]['PASSPHRASE'] = bytes((iterate_config[i]['PASSPHRASE']), 'utf-8')
corrected_config['SYSTEMS'][i]['CALLSIGN'] = bytes((iterate_config[i]['CALLSIGN']).ljust(8)[:8], 'utf-8')
corrected_config['SYSTEMS'][i]['RX_FREQ']: bytes((iterate_config[i]['RX_FREQ']).ljust(9)[:9], 'utf-8')
corrected_config['SYSTEMS'][i]['TX_FREQ'] = bytes((iterate_config[i]['TX_FREQ']).ljust(9)[:9], 'utf-8')
corrected_config['SYSTEMS'][i]['TX_POWER'] = bytes((iterate_config[i]['TX_POWER']).rjust(2,'0'), 'utf-8')
corrected_config['SYSTEMS'][i]['COLORCODE'] = bytes((iterate_config[i]['COLORCODE']).rjust(2,'0'), 'utf-8')
corrected_config['SYSTEMS'][i]['LATITUDE'] = bytes((iterate_config[i]['LATITUDE']).ljust(8)[:8], 'utf-8')
corrected_config['SYSTEMS'][i]['LONGITUDE'] = bytes((iterate_config[i]['LONGITUDE']).ljust(9)[:9], 'utf-8')
corrected_config['SYSTEMS'][i]['HEIGHT'] = bytes((iterate_config[i]['HEIGHT']).rjust(3,'0'), 'utf-8')
corrected_config['SYSTEMS'][i]['LOCATION'] = bytes((iterate_config[i]['LOCATION']).ljust(20)[:20], 'utf-8')
corrected_config['SYSTEMS'][i]['DESCRIPTION'] = bytes((iterate_config[i]['DESCRIPTION']).ljust(19)[:19], 'utf-8')
corrected_config['SYSTEMS'][i]['SLOTS'] = bytes((iterate_config[i]['SLOTS']), 'utf-8')
corrected_config['SYSTEMS'][i]['URL'] = bytes((iterate_config[i]['URL']).ljust(124)[:124], 'utf-8')
corrected_config['SYSTEMS'][i]['SOFTWARE_ID'] = bytes(('HBNet DMR').ljust(40)[:40], 'utf-8')
corrected_config['SYSTEMS'][i]['PACKAGE_ID'] = bytes(('Dev').ljust(40)[:40], 'utf-8')
corrected_config['SYSTEMS'][i]['OPTIONS'] = b''.join([b'Type=HBlink;', bytes(iterate_config[i]['OPTIONS'], 'utf-8')])
if iterate_config[i]['MODE'] == 'PEER':
corrected_config['SYSTEMS'][i].update({'STATS':{ corrected_config['SYSTEMS'][i].update({'STATS':{
'CONNECTION': 'NO', # NO, RTPL_SENT, AUTHENTICATED, CONFIG-SENT, YES 'CONNECTION': 'NO', # NO, RTPL_SENT, AUTHENTICATED, CONFIG-SENT, YES
'CONNECTED': None, 'CONNECTED': None,
@ -171,17 +194,17 @@ def download_config(L_CONFIG_FILE, cli_file):
'LAST_PING_TX_TIME': 0, 'LAST_PING_TX_TIME': 0,
'LAST_PING_ACK_TIME': 0, 'LAST_PING_ACK_TIME': 0,
}}) }})
if iterate_config[i]['MODE'] == 'XLXPEER': if iterate_config[i]['MODE'] == 'XLXPEER':
corrected_config['SYSTEMS'][i].update({'XLXSTATS': { corrected_config['SYSTEMS'][i].update({'XLXSTATS': {
'CONNECTION': 'NO', # NO, RTPL_SENT, AUTHENTICATED, CONFIG-SENT, YES 'CONNECTION': 'NO', # NO, RTPL_SENT, AUTHENTICATED, CONFIG-SENT, YES
'CONNECTED': None, 'CONNECTED': None,
'PINGS_SENT': 0, 'PINGS_SENT': 0,
'PINGS_ACKD': 0, 'PINGS_ACKD': 0,
'NUM_OUTSTANDING': 0, 'NUM_OUTSTANDING': 0,
'PING_OUTSTANDING': False, 'PING_OUTSTANDING': False,
'LAST_PING_TX_TIME': 0, 'LAST_PING_TX_TIME': 0,
'LAST_PING_ACK_TIME': 0, 'LAST_PING_ACK_TIME': 0,
}}) }})
corrected_config['SYSTEMS'][i]['USE_ACL'] = iterate_config[i]['USE_ACL'] corrected_config['SYSTEMS'][i]['USE_ACL'] = iterate_config[i]['USE_ACL']
corrected_config['SYSTEMS'][i]['SUB_ACL'] = config.acl_build(iterate_config[i]['SUB_ACL'], 16776415) corrected_config['SYSTEMS'][i]['SUB_ACL'] = config.acl_build(iterate_config[i]['SUB_ACL'], 16776415)
@ -190,8 +213,8 @@ def download_config(L_CONFIG_FILE, cli_file):
## for i in iterate_masters: ## for i in iterate_masters:
## iterate_masters['SYSTEMS'] ## iterate_masters['SYSTEMS']
## config.process_acls(corrected_config) ## config.process_acls(corrected_config)
print(corrected_config['SYSTEMS']) ## print(corrected_config['SYSTEMS'])
print('-------') ## print('-------')
return corrected_config return corrected_config
# For exception, write blank dict # For exception, write blank dict
except requests.ConnectionError: except requests.ConnectionError:
@ -233,7 +256,7 @@ def hotspot_proxy(listen_port, port_start, port_stop):
totalPorts = DestPortEnd - DestportStart totalPorts = DestPortEnd - DestportStart
freePorts = totalPorts - count freePorts = totalPorts - count
print("{} ports out of {} in use ({} free)".format(count,totalPorts,freePorts)) logger.info("{} ports out of {} in use ({} free)".format(count,totalPorts,freePorts))
@ -249,7 +272,7 @@ def hotspot_proxy(listen_port, port_start, port_stop):
# target system for a unit is identified # target system for a unit is identified
# format 'unit_id': ('SYSTEM', time) # format 'unit_id': ('SYSTEM', time)
UNIT_MAP = {} UNIT_MAP = {}
BRIDGES = {}
# Timed loop used for reporting HBP status # Timed loop used for reporting HBP status
# #
@ -1321,26 +1344,34 @@ if __name__ == '__main__':
peer_ids, subscriber_ids, talkgroup_ids = mk_aliases(CONFIG) peer_ids, subscriber_ids, talkgroup_ids = mk_aliases(CONFIG)
# Import the ruiles file as a module, and create BRIDGES from it # Import the ruiles file as a module, and create BRIDGES from it
spec = importlib.util.spec_from_file_location("module.name", cli_args.RULES_FILE) ## spec = importlib.util.spec_from_file_location("module.name", cli_args.RULES_FILE)
rules_module = importlib.util.module_from_spec(spec) ## rules_module = importlib.util.module_from_spec(spec)
try: ## print(download_rules(LOCAL_CONFIG, cli_args.CONFIG_FILE))
spec.loader.exec_module(rules_module) ## try:
logger.info('(ROUTER) Routing bridges file found and bridges imported: %s', cli_args.RULES_FILE) ## spec.loader.exec_module(rules_module)
except (ImportError, FileNotFoundError): ## logger.info('(ROUTER) Routing bridges file found and bridges imported: %s', cli_args.RULES_FILE)
sys.exit('(ROUTER) TERMINATING: Routing bridges file not found or invalid: {}'.format(cli_args.RULES_FILE)) ## except (ImportError, FileNotFoundError):
# Attempt to use downloaded rules ## sys.exit('(ROUTER) TERMINATING: Routing bridges file not found or invalid: {}'.format(cli_args.RULES_FILE))
if LOCAL_CONFIG['USER_MANAGER']['REMOTE_CONFIG_ENABLED']: ## # Attempt to use downloaded rules
## if LOCAL_CONFIG['USER_MANAGER']['REMOTE_CONFIG_ENABLED']:
# Build the routing rules file ##
BRIDGES = make_bridges(rules_module.BRIDGES) ## # Build the routing rules file
# Get rule parameter for private calls ## BRIDGES = make_bridges(download_rules(LOCAL_CONFIG, cli_args.CONFIG_FILE)[1]) #make_bridges(rules_module.BRIDGES)
UNIT = download_rules(LOCAL_CONFIG, cli_args.CONFIG_FILE)[0] ## # Get rule parameter for private calls
## UNIT = download_rules(LOCAL_CONFIG, cli_args.CONFIG_FILE)[0]
else: ##
# Build the routing rules file ## else:
BRIDGES = make_bridges(rules_module.BRIDGES) ## try:
# Get rule parameter for private calls ## spec.loader.exec_module(rules_module)
UNIT = rules_module.UNIT ## logger.info('(ROUTER) Routing bridges file found and bridges imported: %s', cli_args.RULES_FILE)
## except (ImportError, FileNotFoundError):
## sys.exit('(ROUTER) TERMINATING: Routing bridges file not found or invalid: {}'.format(cli_args.RULES_FILE))
## spec = importlib.util.spec_from_file_location("module.name", cli_args.RULES_FILE)
## rules_module = importlib.util.module_from_spec(spec)
## # Build the routing rules file
## BRIDGES = make_bridges(rules_module.BRIDGES)
## # Get rule parameter for private calls
## UNIT = rules_module.UNIT
# INITIALIZE THE REPORTING LOOP # INITIALIZE THE REPORTING LOOP
if CONFIG['REPORTS']['REPORT']: if CONFIG['REPORTS']['REPORT']:
@ -1375,6 +1406,7 @@ if __name__ == '__main__':
'MODE': 'MASTER', 'MODE': 'MASTER',
'ENABLED': True, 'ENABLED': True,
'STATIC_APRS_POSITION_ENABLED': CONFIG['SYSTEMS'][i]['STATIC_APRS_POSITION_ENABLED'], 'STATIC_APRS_POSITION_ENABLED': CONFIG['SYSTEMS'][i]['STATIC_APRS_POSITION_ENABLED'],
'USE_USER_MAN': CONFIG['SYSTEMS'][i]['USE_USER_MAN'],
'REPEAT': CONFIG['SYSTEMS'][i]['REPEAT'], 'REPEAT': CONFIG['SYSTEMS'][i]['REPEAT'],
'MAX_PEERS': 1, 'MAX_PEERS': 1,
'IP': '127.0.0.1', 'IP': '127.0.0.1',
@ -1393,7 +1425,29 @@ if __name__ == '__main__':
# Remove original MASTER stanza to prevent errors # Remove original MASTER stanza to prevent errors
CONFIG['SYSTEMS'].pop(i) CONFIG['SYSTEMS'].pop(i)
logger.info('Generated MASTER instances for proxy set: ' + i) logger.info('Generated MASTER instances for proxy set: ' + i)
# Attempt to use downloaded rules
if LOCAL_CONFIG['USER_MANAGER']['REMOTE_CONFIG_ENABLED']:
# Build the routing rules file
BRIDGES = make_bridges(download_rules(LOCAL_CONFIG, cli_args.CONFIG_FILE)[1]) #make_bridges(rules_module.BRIDGES)
# Get rule parameter for private calls
UNIT = download_rules(LOCAL_CONFIG, cli_args.CONFIG_FILE)[0]
else:
try:
spec.loader.exec_module(rules_module)
logger.info('(ROUTER) Routing bridges file found and bridges imported: %s', cli_args.RULES_FILE)
except (ImportError, FileNotFoundError):
sys.exit('(ROUTER) TERMINATING: Routing bridges file not found or invalid: {}'.format(cli_args.RULES_FILE))
spec = importlib.util.spec_from_file_location("module.name", cli_args.RULES_FILE)
rules_module = importlib.util.module_from_spec(spec)
# Build the routing rules file
BRIDGES = make_bridges(rules_module.BRIDGES)
# Get rule parameter for private calls
UNIT = rules_module.UNIT
for system in CONFIG['SYSTEMS']: for system in CONFIG['SYSTEMS']:
if CONFIG['SYSTEMS'][system]['ENABLED']: if CONFIG['SYSTEMS'][system]['ENABLED']:
if CONFIG['SYSTEMS'][system]['MODE'] == 'OPENBRIDGE': if CONFIG['SYSTEMS'][system]['MODE'] == 'OPENBRIDGE':
@ -1422,5 +1476,4 @@ if __name__ == '__main__':
with open(CONFIG['USER_MANAGER']['BURN_FILE'], 'w') as f: with open(CONFIG['USER_MANAGER']['BURN_FILE'], 'w') as f:
f.write(str(download_burnlist(CONFIG))) f.write(str(download_burnlist(CONFIG)))
reactor.run() reactor.run()

4
hblink.py
View File

@ -435,7 +435,7 @@ class HBSYSTEM(DatagramProtocol):
# Aliased in __init__ to datagramReceived if system is a master # Aliased in __init__ to datagramReceived if system is a master
def master_datagramReceived(self, _data, _sockaddr): def master_datagramReceived(self, _data, _sockaddr):
global user_db ## global user_db
# Keep This Line Commented Unless HEAVILY Debugging! # Keep This Line Commented Unless HEAVILY Debugging!
# logger.debug('(%s) RX packet from %s -- %s', self._system, _sockaddr, ahex(_data)) # logger.debug('(%s) RX packet from %s -- %s', self._system, _sockaddr, ahex(_data))
@ -525,7 +525,7 @@ class HBSYSTEM(DatagramProtocol):
user_auth = self.ums_response['allow'] user_auth = self.ums_response['allow']
else: else:
user_auth = False user_auth = False
print(user_auth) ## print(user_auth)
if self._config['USE_USER_MAN'] == False: if self._config['USE_USER_MAN'] == False:
# print('False') # print('False')
if acl_check(_peer_id, self._CONFIG['GLOBAL']['REG_ACL']) and acl_check(_peer_id, self._config['REG_ACL']): if acl_check(_peer_id, self._CONFIG['GLOBAL']['REG_ACL']) and acl_check(_peer_id, self._config['REG_ACL']):

204
hotspot_proxy_v2.py Normal file
View File

@ -0,0 +1,204 @@
from twisted.internet.protocol import DatagramProtocol
from twisted.internet import reactor, task
from time import time
from resettabletimer import ResettableTimer
from dmr_utils3.utils import int_id
import random
# Does anybody read this stuff? There's a PEP somewhere that says I should do this.
__author__ = 'Simon Adlem - G7RZU'
__copyright__ = 'Copyright (c) Simon Adlem, G7RZU 2020,2021'
__credits__ = 'Jon Lee, G4TSN; Norman Williams, M6NBP'
__license__ = 'GNU GPLv3'
__maintainer__ = 'Simon Adlem G7RZU'
__email__ = 'simon@gb7fr.org.uk'
class Proxy(DatagramProtocol):
def __init__(self,Master,ListenPort,connTrack,blackList,Timeout,Debug,DestportStart,DestPortEnd):
self.master = Master
self.connTrack = connTrack
self.peerTrack = {}
self.timeout = Timeout
self.debug = Debug
self.blackList = blackList
self.destPortStart = DestportStart
self.destPortEnd = DestPortEnd
self.numPorts = DestPortEnd - DestportStart
def reaper(self,_peer_id):
if self.debug:
print("dead",_peer_id)
self.transport.write(b'RPTCL'+_peer_id, ('127.0.0.1',self.peerTrack[_peer_id]['dport']))
self.connTrack[self.peerTrack[_peer_id]['dport']] = False
del self.peerTrack[_peer_id]
def datagramReceived(self, data, addr):
# HomeBrew Protocol Commands
DMRD = b'DMRD'
DMRA = b'DMRA'
MSTCL = b'MSTCL'
MSTNAK = b'MSTNAK'
MSTPONG = b'MSTPONG'
MSTN = b'MSTN'
MSTP = b'MSTP'
MSTC = b'MSTC'
RPTL = b'RPTL'
RPTPING = b'RPTPING'
RPTCL = b'RPTCL'
RPTL = b'RPTL'
RPTACK = b'RPTACK'
RPTK = b'RPTK'
RPTC = b'RPTC'
RPTP = b'RPTP'
RPTA = b'RPTA'
RPTO = b'RPTO'
host,port = addr
nowtime = time()
Debug = self.debug
#If the packet comes from the master
if host == self.master:
_command = data[:4]
if _command == DMRD:
_peer_id = data[11:15]
elif _command == RPTA:
if data[6:10] in self.peerTrack:
_peer_id = data[6:10]
else:
_peer_id = self.connTrack[port]
elif _command == MSTN:
_peer_id = data[6:10]
self.peerTrack[_peer_id]['timer'].cancel()
self.reaper(_peer_id)
return
elif _command == MSTP:
_peer_id = data[7:11]
elif _command == MSTC:
_peer_id = data[5:9]
self.peerTrack[_peer_id]['timer'].cancel()
self.reaper(_peer_id)
return
# _peer_id = self.connTrack[port]
if self.debug:
print(data)
if _peer_id and _peer_id in self.peerTrack:
self.transport.write(data,(self.peerTrack[_peer_id]['shost'],self.peerTrack[_peer_id]['sport']))
#self.peerTrack[_peer_id]['timer'].reset()
return
else:
_command = data[:4]
if _command == DMRD: # DMRData -- encapsulated DMR data frame
_peer_id = data[11:15]
elif _command == DMRA: # DMRAlias -- Talker Alias information
_peer_id = _data[4:8]
elif _command == RPTL: # RPTLogin -- a repeater wants to login
_peer_id = data[4:8]
elif _command == RPTK: # Repeater has answered our login challenge
_peer_id = data[4:8]
elif _command == RPTC: # Repeater is sending it's configuraiton OR disconnecting
if data[:5] == RPTCL: # Disconnect command
_peer_id = data[5:9]
else:
_peer_id = data[4:8] # Configure Command
elif _command == RPTO: # options
_peer_id = data[4:8]
elif _command == RPTP: # RPTPing -- peer is pinging us
_peer_id = data[7:11]
else:
return
if _peer_id in self.peerTrack:
_dport = self.peerTrack[_peer_id]['dport']
self.peerTrack[_peer_id]['sport'] = port
self.peerTrack[_peer_id]['shost'] = host
self.transport.write(data, ('127.0.0.1',_dport))
self.peerTrack[_peer_id]['timer'].reset()
if self.debug:
print(data)
print(_dport)
return
else:
if int_id(_peer_id) in self.blackList:
return
#for _dport in self.connTrack:
while True:
_dport = random.randint(1,(self.numPorts - 1))
_dport = _dport + self.destPortStart
if not self.connTrack[_dport]:
break
self.connTrack[_dport] = _peer_id
self.peerTrack[_peer_id] = {}
self.peerTrack[_peer_id]['dport'] = _dport
self.peerTrack[_peer_id]['sport'] = port
self.peerTrack[_peer_id]['shost'] = host
self.peerTrack[_peer_id]['timer'] = ResettableTimer(self.timeout,self.reaper,[_peer_id])
self.peerTrack[_peer_id]['timer'].start()
self.transport.write(data, (self.master,_dport))
if self.debug:
print(data)
return
if __name__ == '__main__':
#*** CONFIG HERE ***
Master = "127.0.0.1"
ListenPort = 62031
DestportStart = 54100
DestPortEnd = 54102
Timeout = 30
Stats = True
Debug = True
BlackList = [1234567]
#*******************
CONNTRACK = {}
for port in range(DestportStart,DestPortEnd+1,1):
CONNTRACK[port] = False
reactor.listenUDP(ListenPort,Proxy(Master,ListenPort,CONNTRACK,BlackList,Timeout,Debug,DestportStart,DestPortEnd))
def loopingErrHandle(failure):
print('(GLOBAL) STOPPING REACTOR TO AVOID MEMORY LEAK: Unhandled error innowtimed loop.\n {}'.format(failure))
reactor.stop()
def stats():
count = 0
nowtime = time()
for port in CONNTRACK:
if CONNTRACK[port]:
count = count+1
totalPorts = DestPortEnd - DestportStart
freePorts = totalPorts - count
print("{} ports out of {} in use ({} free)".format(count,totalPorts,freePorts))
if Stats == True:
stats_task = task.LoopingCall(stats)
statsa = stats_task.start(30)
statsa.addErrback(loopingErrHandle)
reactor.run()

198
user_managment/app.py
View File

@ -348,6 +348,7 @@ def create_app():
reset = db.Column(db.String(100, collation='NOCASE'), nullable=False, server_default='') reset = db.Column(db.String(100, collation='NOCASE'), nullable=False, server_default='')
server = db.Column(db.String(100, collation='NOCASE'), nullable=False, server_default='') server = db.Column(db.String(100, collation='NOCASE'), nullable=False, server_default='')
public_list = db.Column(db.Boolean(), nullable=False, server_default='0') public_list = db.Column(db.Boolean(), nullable=False, server_default='0')
proxy = db.Column(db.Boolean(), nullable=False, server_default='0')
class BridgeList(db.Model): class BridgeList(db.Model):
__tablename__ = 'bridge_list' __tablename__ = 'bridge_list'
@ -1561,12 +1562,11 @@ def create_app():
return render_template('flask_user_layout.html', markup_content = Markup(content)) return render_template('flask_user_layout.html', markup_content = Markup(content))
def get_peer_configs(_server_name): def get_peer_configs(_server_name):
mmdvm_pl = mmdvmPeer.query.filter_by(server=_server_name).all() mmdvm_pl = mmdvmPeer.query.filter_by(server=_server_name).filter_by(enabled=True).all()
xlx_pl = xlxPeer.query.filter_by(server=_server_name).all() xlx_pl = xlxPeer.query.filter_by(server=_server_name).filter_by(enabled=True).all()
## print(mmdvm_pl) ## print(mmdvm_pl)
peer_config_list = {} peer_config_list = {}
for i in mmdvm_pl: for i in mmdvm_pl:
## print(i)
## print(i.master_ip) ## print(i.master_ip)
peer_config_list.update({i.name: { peer_config_list.update({i.name: {
'MODE': 'PEER', 'MODE': 'PEER',
@ -1578,32 +1578,31 @@ def create_app():
'MASTER_SOCKADDR': (gethostbyname(i.master_ip), i.master_port), 'MASTER_SOCKADDR': (gethostbyname(i.master_ip), i.master_port),
'MASTER_IP': i.master_ip, 'MASTER_IP': i.master_ip,
'MASTER_PORT': i.master_port, 'MASTER_PORT': i.master_port,
'PASSPHRASE': bytes((i.passphrase), 'utf-8'),
'CALLSIGN': bytes((i.callsign).ljust(8)[:8], 'utf-8'), 'PASSPHRASE': i.passphrase,
'CALLSIGN': i.callsign,
'RADIO_ID': int(i.radio_id), #int(i.radio_id).to_bytes(4, 'big'), 'RADIO_ID': int(i.radio_id), #int(i.radio_id).to_bytes(4, 'big'),
'RX_FREQ': bytes((i.rx_freq).ljust(9)[:9], 'utf-8'), 'RX_FREQ': i.rx_freq,
'TX_FREQ': bytes((i.tx_freq).ljust(9)[:9], 'utf-8'), 'TX_FREQ': i.tx_freq,
'TX_POWER': bytes((i.tx_power).rjust(2,'0'), 'utf-8'), 'TX_POWER': i.tx_power,
'COLORCODE': bytes((i.color_code).rjust(2,'0'), 'utf-8'), 'COLORCODE': i.color_code,
'LATITUDE': bytes((i.latitude).ljust(8)[:8], 'utf-8'), 'LATITUDE': i.latitude,
'LONGITUDE': bytes((i.longitude).ljust(9)[:9], 'utf-8'), 'LONGITUDE': i.longitude,
'HEIGHT': bytes((i.height).rjust(3,'0'), 'utf-8'), 'HEIGHT': i.height,
'LOCATION': bytes((i.location).ljust(20)[:20], 'utf-8'), 'LOCATION': i.location,
'DESCRIPTION': bytes((i.description).ljust(19)[:19], 'utf-8'), 'DESCRIPTION': i.description,
'SLOTS': bytes((i.slots), 'utf-8'), 'SLOTS': i.slots,
'URL': bytes((i.url).ljust(124)[:124], 'utf-8'), 'URL': i.url,
'SOFTWARE_ID': bytes((i.software_id).ljust(40)[:40], 'utf-8'),
'PACKAGE_ID': bytes((i.package_id).ljust(40)[:40], 'utf-8'),
'GROUP_HANGTIME': i.group_hangtime, 'GROUP_HANGTIME': i.group_hangtime,
'OPTIONS': b''.join([b'Type=HBlink;', bytes(i.options, 'utf-8')]), 'OPTIONS': i.options,
'USE_ACL': i.use_acl, 'USE_ACL': i.use_acl,
'SUB_ACL': i.sub_acl, 'SUB_ACL': i.sub_acl,
'TG1_ACL': i.tg1_acl, 'TG1_ACL': i.tg1_acl,
'TG2_ACL': i.tg2_acl 'TG2_ACL': i.tg2_acl
}}) }})
for i in xlx_pl: for i in xlx_pl:
peer_config_list.update({i: { peer_config_list.update({i.name: {
'MODE': 'XLX', 'MODE': 'XLXPEER',
'ENABLED': i.enabled, 'ENABLED': i.enabled,
'LOOSE': i.loose, 'LOOSE': i.loose,
'SOCK_ADDR': (gethostbyname(i.ip), i.port), 'SOCK_ADDR': (gethostbyname(i.ip), i.port),
@ -1612,31 +1611,31 @@ def create_app():
'MASTER_SOCKADDR': (gethostbyname(i.master_ip), i.master_port), 'MASTER_SOCKADDR': (gethostbyname(i.master_ip), i.master_port),
'MASTER_IP': i.master_ip, 'MASTER_IP': i.master_ip,
'MASTER_PORT': i.master_port, 'MASTER_PORT': i.master_port,
'PASSPHRASE': bytes((i.passphrase), 'utf-8'),
'CALLSIGN': bytes((i.callsign).ljust(8)[:8], 'utf-8'), 'PASSPHRASE': i.passphrase,
'RADIO_ID': int(i.radio_id), 'CALLSIGN': i.callsign,
'RX_FREQ': bytes((i.rx_freq).ljust(9)[:9], 'utf-8'), 'RADIO_ID': int(i.radio_id), #int(i.radio_id).to_bytes(4, 'big'),
'TX_FREQ': bytes((i.tx_freq).ljust(9)[:9], 'utf-8'), 'RX_FREQ': i.rx_freq,
'TX_POWER': bytes((i.tx_power).rjust(2,'0'), 'utf-8'), 'TX_FREQ': i.tx_freq,
'COLORCODE': bytes((i.color_code).rjust(2,'0'), 'utf-8'), 'TX_POWER': i.tx_power,
'LATITUDE': bytes((i.latitude).ljust(8)[:8], 'utf-8'), 'COLORCODE': i.color_code,
'LONGITUDE': bytes((i.longitude).ljust(9)[:9], 'utf-8'), 'LATITUDE': i.latitude,
'HEIGHT': bytes((i.height).rjust(3,'0'), 'utf-8'), 'LONGITUDE': i.longitude,
'LOCATION': bytes((i.location).ljust(20)[:20], 'utf-8'), 'HEIGHT': i.height,
'DESCRIPTION': bytes((i.description).ljust(19)[:19], 'utf-8'), 'LOCATION': i.location,
'SLOTS': bytes((i.slots), 'utf-8'), 'DESCRIPTION': i.description,
'URL': bytes((i.url).ljust(124)[:124], 'utf-8'), 'SLOTS': i.slots,
'SOFTWARE_ID': bytes(('HBNet DMR').ljust(40)[:40], 'utf-8'), 'URL': i.url,
'PACKAGE_ID': bytes(('Dev').ljust(40)[:40], 'utf-8'), 'OPTIONS': i.options,
'GROUP_HANGTIME': i.group_hangtime, 'GROUP_HANGTIME': i.group_hangtime,
'XLXMODULE': i.xlxmodule, 'XLXMODULE': i.xlxmodule,
'OPTIONS': b''.join([b'Type=HBlink;', bytes(i.options, 'utf-8')]),
'USE_ACL': i.use_acl, 'USE_ACL': i.use_acl,
'SUB_ACL': i.sub_acl, 'SUB_ACL': i.sub_acl,
'TG1_ACL': i.tg1_acl, 'TG1_ACL': i.tg1_acl,
'TG2_ACL': i.tg2_acl 'TG2_ACL': i.tg2_acl
}}) }})
print((peer_config_list)) #### print('peers')
## print('----------------')
return peer_config_list return peer_config_list
def get_burnlist(): def get_burnlist():
@ -1755,33 +1754,97 @@ def create_app():
def generate_rules(_name): def generate_rules(_name):
# generate UNIT list # generate UNIT list
print('get rules')
print(_name)
xlx_p = xlxPeer.query.filter_by(server=_name).all() xlx_p = xlxPeer.query.filter_by(server=_name).all()
mmdvm_p = mmdvmPeer.query.filter_by(server=_name).all() mmdvm_p = mmdvmPeer.query.filter_by(server=_name).all()
all_m = MasterList.query.filter_by(server=_name).all() all_m = MasterList.query.filter_by(server=_name).all()
all_o = OBP.query.filter_by(server=_name).all() all_o = OBP.query.filter_by(server=_name).all()
all_p = ProxyList.query.filter_by(server=_name).all() all_p = ProxyList.query.filter_by(server=_name).all()
rules = BridgeRules.query.filter_by(server=_name).all()
UNIT = [] UNIT = []
BRIDGES = {} BRIDGES = {}
disabled = {}
for i in all_m: for i in all_m:
if i.enable_unit == True: if i.active == False:
UNIT.append(i.name) disabled[i.name] = i.name
else:
if i.enable_unit == True:
UNIT.append(i.name)
for i in all_p: for i in all_p:
if i.enable_unit == True: if i.active == False:
n_systems = i.internal_stop_port - i.internal_start_port disabled[i.name] = i.name
n_count = 0 else:
while n_count < n_systems: if i.enable_unit == True:
UNIT.append(i.name + '-' + str(n_count)) n_systems = i.internal_stop_port - i.internal_start_port
n_count = n_count + 1 n_count = 0
while n_count < n_systems:
UNIT.append(i.name + '-' + str(n_count))
n_count = n_count + 1
for i in all_o: for i in all_o:
if i.enable_unit == True: if i.enabled == False:
UNIT.append(i.name) disabled[i.name] = i.name
else:
if i.enable_unit == True:
UNIT.append(i.name)
for i in xlx_p: for i in xlx_p:
if i.enable_unit == True: if i.enabled == False:
UNIT.append(i.name) disabled[i.name] = i.name
else:
if i.enable_unit == True:
UNIT.append(i.name)
for i in mmdvm_p: for i in mmdvm_p:
if i.enable_unit == True: if i.enabled == False:
UNIT.append(i.name) disabled[i.name] = i.name
print(UNIT) else:
if i.enable_unit == True:
UNIT.append(i.name)
temp_dict = {}
# populate dict with needed bridges
for r in rules:
## print(r.bridge_name)
## b = BridgeRules.query.filter_by(server=_name).filter_by(server=_name).all()
## for d in temp_dict.items():
## if r.bridge_name == d[0]:
## print('update rule')
## if r.bridge_name != d[0]:
## print('add dict entry and rule')
temp_dict[r.bridge_name] = []
## print(temp_dict)
BRIDGES = temp_dict.copy()
for r in temp_dict.items():
b = BridgeRules.query.filter_by(bridge_name=r[0]).filter_by(server=_name).all()
for s in b:
try:
if s.system_name == disabled[s.system_name]:
pass
except:
if s.timeout == '':
timeout = 0
else:
timeout = int(s.timeout)
if s.proxy == True:
p = ProxyList.query.filter_by(server=_name).filter_by(name=s.system_name).first()
print(p.external_port)
n_systems = p.internal_stop_port - p.internal_start_port
n_count = 0
while n_count < n_systems:
BRIDGES[r[0]].append({'SYSTEM': s.system_name + '-' + str(n_count), 'TS': s.ts, 'TGID': s.tg, 'ACTIVE': s.active, 'TIMEOUT': timeout, 'TO_TYPE': s.to_type, 'ON': ast.literal_eval(str('[' + s.on + ']')), 'OFF': ast.literal_eval(str('[' + s.off + ']')), 'RESET': ast.literal_eval(str('[' + s.reset + ']'))})
n_count = n_count + 1
else:
BRIDGES[r[0]].append({'SYSTEM': s.system_name, 'TS': s.ts, 'TGID': s.tg, 'ACTIVE': s.active, 'TIMEOUT': timeout, 'TO_TYPE': s.to_type, 'ON': ast.literal_eval(str('[' + s.on + ']')), 'OFF': ast.literal_eval(str('[' + s.off + ']')), 'RESET': ast.literal_eval(str('[' + s.reset + ']'))})
## for d in b:
## print(b.system_name)
## if r.bridge_name == d[0]:
## print('update rule')
## if r.bridge_name != d[0]:
## print('add dict entry and rule')
## print(r.tg)
## print(BRIDGES)
return [UNIT, BRIDGES] return [UNIT, BRIDGES]
@ -1838,9 +1901,9 @@ def create_app():
## print(_name) ## print(_name)
#s = ServerList.query.filter_by(name=_name).first() #s = ServerList.query.filter_by(name=_name).first()
# print(s.name) # print(s.name)
i = MasterList.query.filter_by(server=_name).all() i = MasterList.query.filter_by(server=_name).filter_by(active=True).all()
o = OBP.query.filter_by(server=_name).all() o = OBP.query.filter_by(server=_name).filter_by(enabled=True).all()
p = ProxyList.query.filter_by(server=_name).all() p = ProxyList.query.filter_by(server=_name).filter_by(active=True).all()
print('get masters') print('get masters')
master_config_list = {} master_config_list = {}
## master_config_list['SYSTEMS'] = {} ## master_config_list['SYSTEMS'] = {}
@ -1856,7 +1919,7 @@ def create_app():
'MAX_PEERS': m.max_peers, 'MAX_PEERS': m.max_peers,
'IP': m.ip, 'IP': m.ip,
'PORT': m.port, 'PORT': m.port,
'PASSPHRASE': bytes(m.passphrase, 'utf-8'), 'PASSPHRASE': m.passphrase, #bytes(m.passphrase, 'utf-8'),
'GROUP_HANGTIME': m.group_hang_time, 'GROUP_HANGTIME': m.group_hang_time,
'USE_ACL': m.use_acl, 'USE_ACL': m.use_acl,
'REG_ACL': m.reg_acl, 'REG_ACL': m.reg_acl,
@ -1873,7 +1936,7 @@ def create_app():
'NETWORK_ID': obp.network_id, #int(obp.network_id).to_bytes(4, 'big'), 'NETWORK_ID': obp.network_id, #int(obp.network_id).to_bytes(4, 'big'),
'IP': gethostbyname(obp.ip), 'IP': gethostbyname(obp.ip),
'PORT': obp.port, 'PORT': obp.port,
'PASSPHRASE': bytes(obp.passphrase.ljust(20,'\x00')[:20], 'utf-8'), 'PASSPHRASE': obp.passphrase, #bytes(obp.passphrase.ljust(20,'\x00')[:20], 'utf-8'),
'TARGET_SOCK': (obp.target_ip, obp.target_port), 'TARGET_SOCK': (obp.target_ip, obp.target_port),
'TARGET_IP': gethostbyname(obp.target_ip), 'TARGET_IP': gethostbyname(obp.target_ip),
'TARGET_PORT': obp.target_port, 'TARGET_PORT': obp.target_port,
@ -1891,7 +1954,7 @@ def create_app():
'STATIC_APRS_POSITION_ENABLED': pr.static_positions, 'STATIC_APRS_POSITION_ENABLED': pr.static_positions,
'USE_USER_MAN': pr.enable_um, 'USE_USER_MAN': pr.enable_um,
'REPEAT': pr.repeat, 'REPEAT': pr.repeat,
'PASSPHRASE': bytes(pr.passphrase, 'utf-8'), 'PASSPHRASE': pr.passphrase, #bytes(pr.passphrase, 'utf-8'),
'EXTERNAL_PORT': pr.external_port, 'EXTERNAL_PORT': pr.external_port,
'INTERNAL_PORT_START': pr.internal_start_port, 'INTERNAL_PORT_START': pr.internal_start_port,
'INTERNAL_PORT_STOP': pr.internal_stop_port, 'INTERNAL_PORT_STOP': pr.internal_stop_port,
@ -1908,6 +1971,13 @@ def create_app():
return master_config_list return master_config_list
def add_system_rule(_bridge_name, _system_name, _ts, _tg, _active, _timeout, _to_type, _on, _off, _reset, _server, _public_list): def add_system_rule(_bridge_name, _system_name, _ts, _tg, _active, _timeout, _to_type, _on, _off, _reset, _server, _public_list):
proxy = ProxyList.query.filter_by(server=_server).filter_by(name=_system_name).first()
is_proxy = False
try:
if _system_name == proxy.name:
is_proxy = True
except:
pass
add_system = BridgeRules( add_system = BridgeRules(
bridge_name = _bridge_name, bridge_name = _bridge_name,
system_name = _system_name, system_name = _system_name,
@ -1920,7 +1990,8 @@ def create_app():
off = _off, off = _off,
reset = _reset, reset = _reset,
server = _server, server = _server,
public_list = _public_list public_list = _public_list,
proxy = is_proxy
) )
db.session.add(add_system) db.session.add(add_system)
db.session.commit() db.session.commit()
@ -4525,7 +4596,7 @@ def create_app():
return render_template('flask_user_layout.html', markup_content = Markup(content)) return render_template('flask_user_layout.html', markup_content = Markup(content))
@app.route('/auth', methods=['POST']) @app.route('/svr', methods=['POST'])
def auth(): def auth():
hblink_req = request.json hblink_req = request.json
print((hblink_req)) print((hblink_req))
@ -4596,6 +4667,7 @@ def create_app():
if hblink_req['get_config']: if hblink_req['get_config']:
## try: ## try:
## print(get_peer_configs(hblink_req['get_config']))
response = jsonify( response = jsonify(
config=server_get(hblink_req['get_config']), config=server_get(hblink_req['get_config']),
peers=get_peer_configs(hblink_req['get_config']), peers=get_peer_configs(hblink_req['get_config']),