예제 #1
0
 def group_voice(self, _network, _src_sub, _dst_sub, _ts, _end, _peerid,
                 _data):
     if HEX_TGID == _dst_sub and _ts in GROUP_TS:
         if not _end:
             if not self.CALL_DATA:
                 logger.info(
                     '(%s) Receiving transmission to be played back from subscriber: %s',
                     _network, int_id(_src_sub))
             _tmp_data = _data
             #_tmp_data = dmr_nat(_data, _src_sub, NETWORK[_network]['LOCAL']['RADIO_ID'])
             self.CALL_DATA.append(_tmp_data)
         if _end:
             self.CALL_DATA.append(_data)
             time.sleep(2)
             logger.info(
                 '(%s) Playing back transmission from subscriber: %s',
                 _network, int_id(_src_sub))
             for i in self.CALL_DATA:
                 _tmp_data = i
                 _tmp_data = _tmp_data.replace(
                     _peerid, NETWORK[_network]['LOCAL']['RADIO_ID'])
                 if GROUP_SRC_SUB:
                     _tmp_data = _tmp_data.replace(
                         _src_sub, HEX_GRP_SUB)
                 _tmp_data = self.hashed_packet(
                     NETWORK[_network]['LOCAL']['AUTH_KEY'], _tmp_data)
                 # Send the packet to all peers in the target IPSC
                 self.send_to_ipsc(_tmp_data)
                 time.sleep(0.06)
             self.CALL_DATA = []
예제 #2
0
 def private_voice(self, _network, _src_sub, _dst_sub, _ts, _end,
                   _peerid, _data):
     if HEX_SUB == _dst_sub and _ts in PRIVATE_TS:
         if not _end:
             if not self.CALL_DATA:
                 logger.info(
                     '(%s) Receiving transmission to be played back from subscriber: %s, to subscriber: %s',
                     _network, int_id(_src_sub), int_id(_dst_sub))
             _tmp_data = _data
             self.CALL_DATA.append(_tmp_data)
         if _end:
             self.CALL_DATA.append(_data)
             time.sleep(1)
             logger.info(
                 '(%s) Playing back transmission from subscriber: %s, to subscriber %s',
                 _network, int_id(_src_sub), int_id(_dst_sub))
             _orig_src = _src_sub
             _orig_dst = _dst_sub
             for i in self.CALL_DATA:
                 _tmp_data = i
                 _tmp_data = _tmp_data.replace(
                     _peerid, NETWORK[_network]['LOCAL']['RADIO_ID'])
                 _tmp_data = _tmp_data.replace(_dst_sub, BOGUS_SUB)
                 _tmp_data = _tmp_data.replace(_src_sub, _orig_dst)
                 _tmp_data = _tmp_data.replace(BOGUS_SUB, _orig_src)
                 _tmp_data = self.hashed_packet(
                     NETWORK[_network]['LOCAL']['AUTH_KEY'], _tmp_data)
                 # Send the packet to all peers in the target IPSC
                 self.send_to_ipsc(_tmp_data)
                 time.sleep(0.06)
             self.CALL_DATA = []
예제 #3
0
파일: log.py 프로젝트: cyber5tar86/DMRlink
 def group_data(self, _network, _src_sub, _dst_sub, _ts, _end, _peerid,
                _data):
     _dst_sub = get_info(int_id(_dst_sub), talkgroup_ids)
     _peerid = get_info(int_id(_peerid), peer_ids)
     _src_sub = get_info(int_id(_src_sub), subscriber_ids)
     print('({}) Group Data Packet Received From: {}'.format(
         _network, _src_sub))
예제 #4
0
파일: log.py 프로젝트: cyber5tar86/DMRlink
 def private_data(self, _network, _src_sub, _dst_sub, _ts, _end, _peerid,
                  _data):
     _dst_sub = get_info(int_id(_dst_sub), subscriber_ids)
     _peerid = get_info(int_id(_peerid), peer_ids)
     _src_sub = get_info(int_id(_src_sub), subscriber_ids)
     print('({}) Private Data Packet Received From: {} To: {}'.format(
         _network, _src_sub, _dst_sub))
예제 #5
0
파일: rcm.py 프로젝트: ebook/DMRlink
 def call_mon_origin(self, _network, _data):
     _source = _data[1:5]
     _ipsc_src = _data[5:9]
     _rf_src = _data[16:19]
     _rf_tgt = _data[19:22]
     
     _ts = _data[13]
     _status = _data[15]
     _type = _data[22]
     _sec = _data[24]
     
     _ipsc_src = get_info(int_id(_ipsc_src), peer_ids)
     _rf_src = get_info(int_id(_rf_src), subscriber_ids)
     
     if _type == '\x4F' or '\x51':
         _rf_tgt = get_info(int_id(_rf_tgt), talkgroup_ids)
     else:
         _rf_tgt = get_info(int_id(_rf_tgt), subscriber_ids)
     
     print('IPSC:        ', _network)
     print('IPSC Source: ', _ipsc_src)
     print('Timeslot:    ', TS[_ts])
     print('Status:      ', STATUS[_status])
     print('Type:        ', TYPE[_type])
     print('Source Sub:  ', _rf_src)
     print('Target Sub:  ', _rf_tgt)
     print()
예제 #6
0
    def call_mon_status(self, _network, _data):
        _source = int_id(_data[1:5])
        _ipsc_src = int_id(_data[5:9])
        _ts = TS[_data[13]]
        _status = _data[15]  # suspect [14:16] but nothing in leading byte?
        _rf_src = int_id(_data[16:19])
        _rf_tgt = int_id(_data[19:22])
        _type = _data[22]

        try:
            _status = STATUS[_status]
        except KeyError:
            pass
        try:
            _type = TYPE[_type]
        except KeyError:
            pass

        con = pymysql.connect(host=db_host,
                              port=db_port,
                              user=db_user,
                              passwd=db_pwd,
                              db=db_name)
        cur = con.cursor()
        cur.execute(
            "insert INTO rcm_status(data_source, ipsc, timeslot, type, subscriber, talkgroup, status) VALUES(%s, %s, %s, %s, %s, %s, %s)",
            (_source, _ipsc_src, _ts, _type, _rf_src, _rf_tgt, _status))
        con.commit()
        con.close()
예제 #7
0
    def group_voice(self, _network, _src_sub, _dst_sub, _ts, _end, _peerid,
                    _data):
        # THIS FUNCTION IS NOT COMPLETE!!!!
        _payload_type = _data[30:31]
        # _ambe_frames = _data[33:52]
        _ambe_frames = BitArray('0x' + h(_data[33:52]))
        _ambe_frame1 = _ambe_frames[0:49]
        _ambe_frame2 = _ambe_frames[50:99]
        _ambe_frame3 = _ambe_frames[100:149]

        _tg_id = int_id(_dst_sub)
        if _tg_id in self._tg_filter:  #All TGs
            _dst_sub = get_info(int_id(_dst_sub), talkgroup_ids)
            if _payload_type == BURST_DATA_TYPE['VOICE_HEAD']:
                if self._currentTG == self._no_tg:
                    _src_sub = get_info(int_id(_src_sub), subscriber_ids)
                    print(
                        'Voice Transmission Start on TS {} and TG {} ({}) from {}'
                        .format("2" if _ts else "1", _dst_sub, _tg_id,
                                _src_sub))
                    self._currentTG = _tg_id
                    self._transmitStartTime = time()
                else:
                    if self._currentTG != _tg_id:
                        if time() > self.lastPacketTimeout:
                            self._currentTG = self._no_tg  #looks like we never saw an EOT from the last stream
                            print('EOT timeout')
                        else:
                            print(
                                'Transmission in progress, will not decode stream on TG {}'
                                .format(_tg_id))
            if self._currentTG == _tg_id:
                if _payload_type == BURST_DATA_TYPE['VOICE_TERM']:
                    print('Voice Transmission End %.2f seconds' %
                          (time() - self._transmitStartTime))
                    self._currentTG = self._no_tg
                if _payload_type == BURST_DATA_TYPE['SLOT1_VOICE']:
                    self.outputFrames(_ambe_frames, _ambe_frame1, _ambe_frame2,
                                      _ambe_frame3)
                if _payload_type == BURST_DATA_TYPE['SLOT2_VOICE']:
                    self.outputFrames(_ambe_frames, _ambe_frame1, _ambe_frame2,
                                      _ambe_frame3)
                self.lastPacketTimeout = time() + 10

        else:
            if _payload_type == BURST_DATA_TYPE['VOICE_HEAD']:
                _dst_sub = get_info(int_id(_dst_sub), talkgroup_ids)
                print('Ignored Voice Transmission Start on TS {} and TG {}'.
                      format("2" if _ts else "1", _dst_sub))
예제 #8
0
파일: log.py 프로젝트: KD8EYF/DMRlink
 def private_voice(self, _network, _src_sub, _dst_sub, _ts, _end, _peerid, _data):
 #    _log = logger.debug    
     if (_ts not in self.ACTIVE_CALLS) or _end:
         _time       = time.strftime('%m/%d/%y %H:%M:%S')
         _dst_sub    = get_info(int_id(_dst_sub), subscriber_ids)
         _peerid     = get_info(int_id(_peerid), peer_ids)
         _src_sub    = get_info(int_id(_src_sub), subscriber_ids)
         if not _end:    self.ACTIVE_CALLS.append(_ts)
         if _end:        self.ACTIVE_CALLS.remove(_ts)
     
         if _ts:     _ts = 2
         else:       _ts = 1
         if _end:    _end = 'END'
         else:       _end = 'START'
     
         print('{} ({}) Call {} Private Voice: \n\tIPSC Source:\t{}\n\tSubscriber:\t{}\n\tDestination:\t{}\n\tTimeslot\t{}' .format(_time, _network, _end, _peerid, _src_sub, _dst_sub, _ts))
예제 #9
0
    def call_mon_status(self, _network, _data):
        if not status:
            return
        _source = _data[1:5]
        _ipsc_src = _data[5:9]
        _seq_num = _data[9:13]
        _ts = _data[13]
        _status = _data[15]  # suspect [14:16] but nothing in leading byte?
        _rf_src = _data[16:19]
        _rf_tgt = _data[19:22]
        _type = _data[22]
        _prio = _data[23]
        _sec = _data[24]

        _source = str(int_id(_source)) + ', ' + str(
            get_info(int_id(_source), peer_ids))
        _ipsc_src = str(int_id(_ipsc_src)) + ', ' + str(
            get_info(int_id(_ipsc_src), peer_ids))
        _rf_src = str(int_id(_rf_src)) + ', ' + str(
            get_info(int_id(_rf_src), subscriber_ids))

        if _type == '\x4F' or '\x51':
            _rf_tgt = 'TGID: ' + str(int_id(_rf_tgt)) + ', ' + str(
                get_info(int_id(_rf_tgt), talkgroup_ids))
        else:
            _rf_tgt = 'SID: ' + str(int_id(_rf_tgt)) + ', ' + str(
                get_info(int_id(_rf_tgt), subscriber_ids))

        print('Call Monitor - Call Status')
        print('TIME:        ',
              datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
        print('DATA SOURCE: ', _source)
        print('IPSC:        ', _network)
        print('IPSC Source: ', _ipsc_src)
        print('Timeslot:    ', TS[_ts])
        try:
            print('Status:      ', STATUS[_status])
        except KeyError:
            print('Status (unknown): ', h(_status))
        try:
            print('Type:        ', TYPE[_type])
        except KeyError:
            print('Type (unknown): ', h(_type))
        print('Source Sub:  ', _rf_src)
        print('Target Sub:  ', _rf_tgt)
        print()
예제 #10
0
파일: bridge.py 프로젝트: n8ohu/DMRlink
 def bridge_presence_loop(self):
     _temp_bridge = True
     for peer in BRIDGES:
         _peer = hex_str_4(peer)
     
         if _peer in self._peers.keys() and (self._peers[_peer]['MODE_DECODE']['TS_1'] or self._peers[_peer]['MODE_DECODE']['TS_2']):
             _temp_bridge = False
             logger.debug('(%s) Peer %s is an active bridge', self._network, int_id(_peer))
     
         if _peer == self._master['RADIO_ID'] \
             and self._master['STATUS']['CONNECTED'] \
             and (self._master['MODE_DECODE']['TS_1'] or self._master['MODE_DECODE']['TS_2']):
             _temp_bridge = False
             logger.debug('(%s) Master %s is an active bridge',self._network, int_id(_peer))
     
     if self.BRIDGE != _temp_bridge:
         logger.info('(%s) Changing bridge status to: %s', self._network, _temp_bridge )
     self.BRIDGE = _temp_bridge
예제 #11
0
 def bridge_presence_loop(self):
     _temp_bridge = True
     for peer in BRIDGES:
         _peer = hex_str_4(peer)
     
         if _peer in self._peers.keys() and (self._peers[_peer]['MODE_DECODE']['TS_1'] or self._peers[_peer]['MODE_DECODE']['TS_2']):
             _temp_bridge = False
             logger.debug('(%s) Peer %s is an active bridge', self._network, int_id(_peer))
     
         if _peer == self._master['RADIO_ID'] \
             and self._master['STATUS']['CONNECTED'] \
             and (self._master['MODE_DECODE']['TS_1'] or self._master['MODE_DECODE']['TS_2']):
             _temp_bridge = False
             logger.debug('(%s) Master %s is an active bridge',self._network, int_id(_peer))
     
     if self.BRIDGE != _temp_bridge:
         logger.info('(%s) Changing bridge status to: %s', self._network, _temp_bridge )
     self.BRIDGE = _temp_bridge
예제 #12
0
파일: ambe_audio.py 프로젝트: n8ohu/DMRlink
    def group_voice(self, _network, _src_sub, _dst_sub, _ts, _end, _peerid, _data):
        # THIS FUNCTION IS NOT COMPLETE!!!!
        _payload_type = _data[30:31]
        # _ambe_frames = _data[33:52]
        _ambe_frames = BitArray("0x" + h(_data[33:52]))
        _ambe_frame1 = _ambe_frames[0:49]
        _ambe_frame2 = _ambe_frames[50:99]
        _ambe_frame3 = _ambe_frames[100:149]

        _tg_id = int_id(_dst_sub)
        if _tg_id in self._tg_filter:  # All TGs
            _dst_sub = get_info(int_id(_dst_sub), talkgroup_ids)
            if _payload_type == BURST_DATA_TYPE["VOICE_HEAD"]:
                if self._currentTG == self._no_tg:
                    _src_sub = get_info(int_id(_src_sub), subscriber_ids)
                    print(
                        "Voice Transmission Start on TS {} and TG {} ({}) from {}".format(
                            "2" if _ts else "1", _dst_sub, _tg_id, _src_sub
                        )
                    )
                    self._currentTG = _tg_id
                    self._transmitStartTime = time()
                else:
                    if self._currentTG != _tg_id:
                        if time() > self.lastPacketTimeout:
                            self._currentTG = self._no_tg  # looks like we never saw an EOT from the last stream
                            print("EOT timeout")
                        else:
                            print("Transmission in progress, will not decode stream on TG {}".format(_tg_id))
            if self._currentTG == _tg_id:
                if _payload_type == BURST_DATA_TYPE["VOICE_TERM"]:
                    print("Voice Transmission End %.2f seconds" % (time() - self._transmitStartTime))
                    self._currentTG = self._no_tg
                if _payload_type == BURST_DATA_TYPE["SLOT1_VOICE"]:
                    self.outputFrames(_ambe_frames, _ambe_frame1, _ambe_frame2, _ambe_frame3)
                if _payload_type == BURST_DATA_TYPE["SLOT2_VOICE"]:
                    self.outputFrames(_ambe_frames, _ambe_frame1, _ambe_frame2, _ambe_frame3)
                self.lastPacketTimeout = time() + 10

        else:
            if _payload_type == BURST_DATA_TYPE["VOICE_HEAD"]:
                _dst_sub = get_info(int_id(_dst_sub), talkgroup_ids)
                print("Ignored Voice Transmission Start on TS {} and TG {}".format("2" if _ts else "1", _dst_sub))
예제 #13
0
파일: log.py 프로젝트: cyber5tar86/DMRlink
    def private_voice(self, _network, _src_sub, _dst_sub, _ts, _end, _peerid,
                      _data):
        #    _log = logger.debug
        if (_ts not in self.ACTIVE_CALLS) or _end:
            _time = time.strftime('%m/%d/%y %H:%M:%S')
            _dst_sub = get_info(int_id(_dst_sub), subscriber_ids)
            _peerid = get_info(int_id(_peerid), peer_ids)
            _src_sub = get_info(int_id(_src_sub), subscriber_ids)
            if not _end: self.ACTIVE_CALLS.append(_ts)
            if _end: self.ACTIVE_CALLS.remove(_ts)

            if _ts: _ts = 2
            else: _ts = 1
            if _end: _end = 'END'
            else: _end = 'START'

            print(
                '{} ({}) Call {} Private Voice: \n\tIPSC Source:\t{}\n\tSubscriber:\t{}\n\tDestination:\t{}\n\tTimeslot\t{}'
                .format(_time, _network, _end, _peerid, _src_sub, _dst_sub,
                        _ts))
예제 #14
0
파일: rcm.py 프로젝트: gr0wl3r/DMRlink
 def call_mon_status(self, _network, _data):
     if not status:
         return
     _source =   _data[1:5]
     _ipsc_src = _data[5:9]
     _seq_num =  _data[9:13]
     _ts =       _data[13]
     _status =   _data[15] # suspect [14:16] but nothing in leading byte?
     _rf_src =   _data[16:19]
     _rf_tgt =   _data[19:22]
     _type =     _data[22]
     _prio =     _data[23]
     _sec =      _data[24]
     
     _source = get_info(int_id(_source), peer_ids)
     _ipsc_src = get_info(int_id(_ipsc_src), peer_ids)
     _rf_src = get_info(int_id(_rf_src), subscriber_ids)
     
     if _type == '\x4F' or '\x51':
         _rf_tgt = get_info(int_id(_rf_tgt), talkgroup_ids)
     else:
         _rf_tgt = get_info(int_id(_rf_tgt), subscriber_ids)
     
     print('Call Monitor - Call Status')
     print('TIME:        ', datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
     print('DATA SOURCE: ', _source)
     print('IPSC:        ', _network)
     print('IPSC Source: ', _ipsc_src)
     print('Timeslot:    ', TS[_ts])
     try:
         print('Status:      ', STATUS[_status])
     except KeyError:
         print('Status (unknown): ', h(status))
     try:
         print('Type:        ', TYPE[_type])
     except KeyError:
         print('Type (unknown): ', h(_type))
     print('Source Sub:  ', _rf_src)
     print('Target Sub:  ', _rf_tgt)
     print()
예제 #15
0
파일: rcm.py 프로젝트: cyber5tar86/DMRlink
 def call_mon_rpt(self, _network, _data):
     if not rpt:
         return
     _source    = _data[1:5]
     _ts1_state = _data[5]
     _ts2_state = _data[6]
     
     _source = str(int_id(_source)) + ', ' + str(get_info(int_id(_source), peer_ids))
     
     print('Call Monitor - Repeater State')
     print('TIME:         ', datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
     print('DATA SOURCE:  ', _source)
  
     try:
         print('TS1 State:    ', REPEAT[_ts1_state])
     except KeyError:
         print('TS1 State (unknown): ', h(_ts1_state))
     try:
         print('TS2 State:    ', REPEAT[_ts2_state])
     except KeyError:
         print('TS2 State (unknown): ', h(_ts2_state))
     print()
예제 #16
0
    def call_mon_status(self, _network, _data):
        _source   = int_id(_data[1:5])
        _ipsc_src = int_id(_data[5:9])
        _ts       = TS[_data[13]]
        _status   = _data[15] # suspect [14:16] but nothing in leading byte?
        _rf_src   = int_id(_data[16:19])
        _rf_tgt   = int_id(_data[19:22])
        _type     = _data[22]

        try:
            _status = STATUS[_status]
        except KeyError:
            pass
        try:
            _type = TYPE[_type]
        except KeyError:
            pass
            
        con = pymysql.connect(host = db_host, port = db_port, user = db_user, passwd = db_pwd, db = db_name)
        cur = con.cursor()
        cur.execute("insert INTO rcm_status(data_source, ipsc, timeslot, type, subscriber, talkgroup, status) VALUES(%s, %s, %s, %s, %s, %s, %s)", (_source, _ipsc_src, _ts, _type, _rf_src, _rf_tgt, _status))
        con.commit()
        con.close()
예제 #17
0
파일: bridge.py 프로젝트: acharlton/DMRlink
 def group_voice(self, _network, _src_sub, _dst_group, _ts, _end, _peerid, _data):
     logger.debug('(%s) Group Voice Packet Received From: %s, IPSC Peer %s, Destination %s', _network, int_id(_src_sub), int_id(_peerid), int_id(_dst_group))
     if _ts not in self.ACTIVE_CALLS:
         self.ACTIVE_CALLS.append(_ts)
         # send repeater wake up, but send them when a repeater is likely not TXing check time since end (see below)
     if _end:
         self.ACTIVE_CALLS.remove(_ts)
         # flag the time here so we can test to see if the last call ended long enough ago to send a wake-up
         # timer = time()
     
     for rule in RULES[_network]['GROUP_VOICE']:
         _target = rule['DST_NET']
         # Matching for rules is against the Destination Group in the SOURCE packet (SRC_GROUP)
         if rule['SRC_GROUP'] == _dst_group and rule['SRC_TS'] == _ts and (self.BRIDGE == True or networks[_target].BRIDGE == True):
             _tmp_data = _data
             # Re-Write the IPSC SRC to match the target network's ID
             _tmp_data = _tmp_data.replace(_peerid, NETWORK[_target]['LOCAL']['RADIO_ID'])
             # Re-Write the destination Group ID
             _tmp_data = _tmp_data.replace(_dst_group, rule['DST_GROUP'])
             
             # Re-Write IPSC timeslot value
             _call_info = int_id(_data[17:18])
             if rule['DST_TS'] == 0:
                 _call_info &= ~(1 << 5)
             elif rule['DST_TS'] == 1:
                 _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
             _burst_data_type = _data[30]
             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 rule['DST_TS'] == 0:
                     _burst_data_type = BURST_DATA_TYPE['SLOT1_VOICE']
                 elif rule['DST_TS'] == 1:
                     _burst_data_type = BURST_DATA_TYPE['SLOT2_VOICE']
                 _tmp_data = _tmp_data[:30] + _burst_data_type + _tmp_data[31:]
         
             # Calculate and append the authentication hash for the target network... if necessary
             if NETWORK[_target]['LOCAL']['AUTH_ENABLED']:
                 _tmp_data = self.hashed_packet(NETWORK[_target]['LOCAL']['AUTH_KEY'], _tmp_data)
             # Send the packet to all peers in the target IPSC
             send_to_ipsc(_target, _tmp_data)
예제 #18
0
    def call_mon_rpt(self, _network, _data):
        if not rpt:
            return
        _source = _data[1:5]
        _ts1_state = _data[5]
        _ts2_state = _data[6]

        _source = str(int_id(_source)) + ', ' + str(
            get_info(int_id(_source), peer_ids))

        print('Call Monitor - Repeater State')
        print('TIME:         ',
              datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
        print('DATA SOURCE:  ', _source)

        try:
            print('TS1 State:    ', REPEAT[_ts1_state])
        except KeyError:
            print('TS1 State (unknown): ', h(_ts1_state))
        try:
            print('TS2 State:    ', REPEAT[_ts2_state])
        except KeyError:
            print('TS2 State (unknown): ', h(_ts2_state))
        print()
예제 #19
0
파일: rcm.py 프로젝트: gr0wl3r/DMRlink
 def call_mon_nack(self, _network, _data):
     if not nack:
         return
     _source = _data[1:5]
     _nack =   _data[5]
     
     _source = get_info(int_id(_source), peer_ids)
     
     print('Call Monitor - Transmission NACK')
     print('TIME:        ', datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
     print('DATA SOURCE: ', _source)
     try:
         print('NACK Cause:  ', NACK[_nack])
     except KeyError:
         print('NACK Cause (unknown): ', h(_nack))
     print()
예제 #20
0
 def private_voice(self, _network, _src_sub, _dst_sub, _ts, _end,
                   _peerid, _data):
     if id == _dst_sub and _ts in ts:
         if not _end:
             if not self.CALL_DATA:
                 print(
                     '({}) Recording transmission from subscriber: {}'.
                     format(_network, int_id(_src_sub)))
             self.CALL_DATA.append(_data)
         if _end:
             self.CALL_DATA.append(_data)
             print(
                 '({}) Transmission ended, writing to disk: {}'.format(
                     _network, filename))
             pickle.dump(self.CALL_DATA, open(filename, 'wb'))
             reactor.stop()
             print('Recording created, program terminating')
예제 #21
0
    def call_mon_nack(self, _network, _data):
        if not nack:
            return
        _source = _data[1:5]
        _nack = _data[5]

        _source = get_info(int_id(_source), peer_ids)

        print('Call Monitor - Transmission NACK')
        print('TIME:        ',
              datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
        print('DATA SOURCE: ', _source)
        try:
            print('NACK Cause:  ', NACK[_nack])
        except KeyError:
            print('NACK Cause (unknown): ', h(_nack))
        print()
예제 #22
0
 def private_voice(self, _network, _src_sub, _dst_sub, _ts, _end, _peerid, _data):
     if HEX_SUB == _dst_sub and _ts in PRIVATE_TS:
         if not _end:
             if not self.CALL_DATA:
                 logger.info('(%s) Receiving transmission to be played back from subscriber: %s, to subscriber: %s', _network, int_id(_src_sub), int_id(_dst_sub))
             _tmp_data = _data
             self.CALL_DATA.append(_tmp_data)
         if _end:
             self.CALL_DATA.append(_data)
             time.sleep(1)
             logger.info('(%s) Playing back transmission from subscriber: %s, to subscriber %s', _network, int_id(_src_sub), int_id(_dst_sub))
             _orig_src = _src_sub
             _orig_dst = _dst_sub
             for i in self.CALL_DATA:
                 _tmp_data = i
                 _tmp_data = _tmp_data.replace(_peerid, NETWORK[_network]['LOCAL']['RADIO_ID'])
                 _tmp_data = _tmp_data.replace(_dst_sub, BOGUS_SUB)
                 _tmp_data = _tmp_data.replace(_src_sub, _orig_dst)
                 _tmp_data = _tmp_data.replace(BOGUS_SUB, _orig_src)
                 _tmp_data = self.hashed_packet(NETWORK[_network]['LOCAL']['AUTH_KEY'], _tmp_data)
                 # Send the packet to all peers in the target IPSC
                 send_to_ipsc(_network, _tmp_data)
                 time.sleep(0.06)
             self.CALL_DATA = []
예제 #23
0
 def group_voice(self, _network, _src_sub, _dst_sub, _ts, _end, _peerid, _data):
     if HEX_TGID == _dst_sub and _ts in GROUP_TS:
         if not _end:
             if not self.CALL_DATA:
                 logger.info('(%s) Receiving transmission to be played back from subscriber: %s', _network, int_id(_src_sub))
             _tmp_data = _data
             #_tmp_data = dmr_nat(_data, _src_sub, NETWORK[_network]['LOCAL']['RADIO_ID'])
             self.CALL_DATA.append(_tmp_data)
         if _end:
             self.CALL_DATA.append(_data)
             time.sleep(2)
             logger.info('(%s) Playing back transmission from subscriber: %s', _network, int_id(_src_sub))
             for i in self.CALL_DATA:
                 _tmp_data = i
                 _tmp_data = _tmp_data.replace(_peerid, NETWORK[_network]['LOCAL']['RADIO_ID'])
                 _tmp_data = self.hashed_packet(NETWORK[_network]['LOCAL']['AUTH_KEY'], _tmp_data)
                 # Send the packet to all peers in the target IPSC
                 send_to_ipsc(_network, _tmp_data)
                 time.sleep(0.06)
             self.CALL_DATA = []
예제 #24
0
    def group_voice(self, _network, _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:
            logger.warning('(%s) Group Voice Packet ***REJECTED BY ACL*** From: %s, IPSC Peer %s, Destination %s', _network, int_id(_src_sub), int_id(_peerid), int_id(_dst_group))
            return
        
        # Process the packet
        logger.debug('(%s) Group Voice Packet Received From: %s, IPSC Peer %s, Destination %s', _network, 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)
        if _ts == 0:
            _TS = 'TS1'
        elif _ts == 1:
            _TS = 'TS2'               
        
        now = time() # Mark packet arrival time -- we'll need this for call contention handling 
        
        for rule in RULES[_network]['GROUP_VOICE']:
            _target = rule['DST_NET']               # Shorthand to reduce length and make it easier to read
            _status = networks[_target].IPSC_STATUS # Shorthand to reduce length and make it easier to read

            # Matching for rules is against the Destination Group in the SOURCE packet (SRC_GROUP)
            # if rule['SRC_GROUP'] == _dst_group and rule['SRC_TS'] == _ts:
            # if BRIDGES:
            if (rule['SRC_GROUP'] == _dst_group and rule['SRC_TS'] == _ts and rule['ACTIVE'] == True) and (self.BRIDGE == True or networks[_target].BRIDGE == True):
                
                #
                # BEGIN CONTENTION HANDLING
                # 
                # If this is an inter-DMRlink trunk, this isn't necessary
                if RULES[_network]['TRUNK'] == False: 
                    
                    # 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 ((rule['DST_GROUP'] != _status[_TS]['RX_GROUP']) and ((now - _status[_TS]['RX_TIME']) < RULES[_network]['GROUP_HANGTIME'])):
                        if _burst_data_type == BURST_DATA_TYPE['VOICE_HEAD']:
                            logger.info('(%s) Call not bridged, target active or in group hangtime: IPSC %s, %s, TGID%s', _network, _target, _TS, int_id(rule['DST_GROUP']))
                        continue    
                    if ((rule['DST_GROUP'] != _status[_TS]['TX_GROUP']) and ((now - _status[_TS]['TX_TIME']) < RULES[_network]['GROUP_HANGTIME'])):
                        if _burst_data_type == BURST_DATA_TYPE['VOICE_HEAD']:
                            logger.info('(%s) Call not bridged to destination on TGID %s, target in group hangtime: IPSC %s, %s, TGID%s', _network, int_id(_status[_TS]['TX_GROUP']), _target, _TS, int_id(rule['DST_GROUP']))
                        continue
                    if (rule['DST_GROUP'] == _status[_TS]['RX_GROUP']) and ((now - _status[_TS]['RX_TIME']) < TS_CLEAR_TIME):
                        if _burst_data_type == BURST_DATA_TYPE['VOICE_HEAD']:
                            logger.info('(%s) Call not bridged, matching call already active on target: IPSC %s, %s, TGID%s', _network, _target, _TS, int_id(rule['DST_GROUP']))
                        continue
                    if (rule['DST_GROUP'] == _status[_TS]['TX_GROUP']) and (_src_sub != _status[_TS]['TX_SRC_SUB']) and ((now - _status[_TS]['TX_TIME']) < TS_CLEAR_TIME):
                        if _burst_data_type == BURST_DATA_TYPE['VOICE_HEAD']:
                            logger.info('(%s) Call not bridged, call bridge in progress from %s, target: IPSC %s, %s, TGID%s', _network, int_id(_src_sub), _target, _TS, int_id(rule['DST_GROUP']))
                        continue
                #
                # END CONTENTION HANDLING
                #
                
                
                #
                # 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, NETWORK[_target]['LOCAL']['RADIO_ID'])
                
                # Re-Write the destination Group ID
                _tmp_data = _tmp_data.replace(_dst_group, rule['DST_GROUP'])
            
                # Re-Write IPSC timeslot value
                _call_info = int_id(_data[17:18])
                if rule['DST_TS'] == 0:
                    _call_info &= ~(1 << 5)
                elif rule['DST_TS'] == 1:
                    _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 rule['DST_TS'] == 0:
                        _burst_data_type = BURST_DATA_TYPE['SLOT1_VOICE']
                    elif rule['DST_TS'] == 1:
                        _burst_data_type = BURST_DATA_TYPE['SLOT2_VOICE']
                    _tmp_data = _tmp_data[:30] + _burst_data_type + _tmp_data[31:]
            
                # Calculate and append the authentication hash for the target network... if necessary
                if NETWORK[_target]['LOCAL']['AUTH_ENABLED']:
                    _tmp_data = self.auth_hashed_packet(NETWORK[_target]['LOCAL']['AUTH_KEY'], _tmp_data)
                # Send the packet to all peers in the target IPSC
                networks[_target].send_to_ipsc(_tmp_data)
                #
                # END FRAME FORWARDING
                #
                
                
                # Set values for the contention handler to test next time there is a frame to forward
                _status[_TS]['TX_GROUP'] = rule['DST_GROUP']
                _status[_TS]['TX_TIME'] = now
                _status[_TS]['TX_SRC_SUB'] = _src_sub
                

        # Mark the group and time that a packet was recieved for the contention handler to use later
        self.IPSC_STATUS[_TS]['RX_GROUP'] = _dst_group
        self.IPSC_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 un-key
        if _burst_data_type == BURST_DATA_TYPE['VOICE_TERM']:
            
            # Iterate the rules dictionary
            for rule in RULES[_network]['GROUP_VOICE']:
                
                # TGID matches an ACTIVATION trigger
                if _dst_group in rule['ON']:
                    # Set the matching rule as ACTIVE
                    rule['ACTIVE'] = True
                    logger.info('(%s) Primary Bridge Rule \"%s\" changed to state: %s', _network, rule['NAME'], rule['ACTIVE'])
                    
                    # Set reciprocal rules for other IPSCs as ACTIVE
                    _target = rule['DST_NET']
                    for target_rule in RULES[_target]['GROUP_VOICE']:
                        if target_rule['NAME'] == rule['NAME']:
                            target_rule['ACTIVE'] = True
                            logger.info('(%s) Reciprocal Bridge Rule \"%s\" in IPSC \"%s\" changed to state: %s', _network, target_rule['NAME'], _target, rule['ACTIVE'])
                            
                # TGID matches an DE-ACTIVATION trigger
                if _dst_group in rule['OFF']:
                    # Set the matching rule as ACTIVE
                    rule['ACTIVE'] = False
                    logger.info('(%s) Bridge Rule \"%s\" changed to state: %s', _network, rule['NAME'], rule['ACTIVE'])
                    
                    # Set reciprocal rules for other IPSCs as ACTIVE
                    _target = rule['DST_NET']
                    for target_rule in RULES[_target]['GROUP_VOICE']:
                        if target_rule['NAME'] == rule['NAME']:
                            target_rule['ACTIVE'] = False
                            logger.info('(%s) Reciprocal Bridge Rule \"%s\" in IPSC \"%s\" changed to state: %s', _network, target_rule['NAME'], _target, rule['ACTIVE'])
예제 #25
0
파일: rcm.py 프로젝트: gr0wl3r/DMRlink
 def repeater_wake_up(self, _network, _data):
     _source = _data[1:5]
     _source_dec = int_id(_source)
     _source_name = get_info(_source_dec, peer_ids)
예제 #26
0
 def repeater_wake_up(self, _network, _data):
     _source = _data[1:5]
     _source_dec = int_id(_source)
     _source_name = get_info(_source_dec, peer_ids)
예제 #27
0
    def group_data(self, _network, _src_sub, _dst_sub, _ts, _end, _peerid, _data):    
        logger.debug('(%s) Group Data Packet Received From: %s, IPSC Peer %s, Destination %s', _network, int_id(_src_sub), int_id(_peerid), int_id(_dst_sub))
        
        for target in RULES[_network]['GROUP_DATA']:
            
            if self.BRIDGE == True or networks[target].BRIDGE == True:
                _tmp_data = _data
                # Re-Write the IPSC SRC to match the target network's ID
                _tmp_data = _tmp_data.replace(_peerid, NETWORK[target]['LOCAL']['RADIO_ID'])

                # Calculate and append the authentication hash for the target network... if necessary
                if NETWORK[target]['LOCAL']['AUTH_ENABLED']:
                    _tmp_data = self.auth_hashed_packet(NETWORK[target]['LOCAL']['AUTH_KEY'], _tmp_data)
                # Send the packet to all peers in the target IPSC
                networks[target].send_to_ipsc(_tmp_data)
예제 #28
0
파일: play_group.py 프로젝트: n8ohu/DMRlink
 def group_voice(self, _network, _src_sub, _dst_group, _ts, _end, _peerid, _data):
     if _end:
         _self_peer = NETWORK[_network]['LOCAL']['RADIO_ID']
         _self_src = _self_peer[1:]
         
         if (_peerid == _self_peer) or (_src_sub == _self_src):
             logger.error('(%s) Just received a packet that appears to have been originated by us. PeerID: %s Subscriber: %s TS: %s, TGID: %s', _network, int_id(_peerid), int_id(_src_sub), int(_ts)+1, int_id(_dst_group))
             return
         
         if trigger == False:
             if (_ts == 0 and _dst_group not in trigger_groups_1) or (_ts == 1 and _dst_group not in trigger_groups_2):
                 return
         else:
             if (_ts == 0 and _dst_group in trigger_groups_1) or (_ts == 1 and _dst_group in trigger_groups_2):
                 return
         
         logger.info('(%s) Event ID: %s - Playback triggered from SourceID: %s, TS: %s, TGID: %s, PeerID: %s', _network, self.event_id, int_id(_src_sub), _ts+1, int_id(_dst_group), int_id(_peerid))
         
         # Determine the type of voice packet this is (see top of file for possible types)
         _burst_data_type = _data[30]
             
         time.sleep(2)
         self.CALL_DATA = pickle.load(open(filename, 'rb'))
         logger.info('(%s) Event ID: %s - Playing back file: %s', _network, self.event_id, filename)
        
         for i in self.CALL_DATA:
             _tmp_data = i
             
             # re-Write the peer radio ID to that of this program
             _tmp_data = _tmp_data.replace(_peerid, _self_peer)
             # re-Write the source subscriber ID to that of this program
             _tmp_data = _tmp_data.replace(_src_sub, _self_src)
             # Re-Write the destination Group ID
             _tmp_data = _tmp_data.replace(_tmp_data[9:12], _dst_group)
             
             # Re-Write IPSC timeslot value
             _call_info = int_id(_tmp_data[17:18])
             if _ts == 0:
                 _call_info &= ~(1 << 5)
             elif _ts == 1:
                 _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']:
                 # Re-Write timeslot if necessary...
                 if _ts == 0:
                     _burst_data_type = BURST_DATA_TYPE['SLOT1_VOICE']
                 elif _ts == 1:
                     _burst_data_type = BURST_DATA_TYPE['SLOT2_VOICE']
                 _tmp_data = _tmp_data[:30] + _burst_data_type + _tmp_data[31:]
             
             _tmp_data = self.hashed_packet(NETWORK[_network]['LOCAL']['AUTH_KEY'], _tmp_data)
             # Send the packet to all peers in the target IPSC
             self.send_to_ipsc(_tmp_data)
             time.sleep(0.06)
         self.CALL_DATA = []
         logger.info('(%s) Event ID: %s - Playback Completed', _network, self.event_id)
         self.event_id = self.event_id + 1
예제 #29
0
    def group_voice(self, _network, _src_sub, _dst_group, _ts, _end, _peerid, _data):
        logger.debug('(%s) Group Voice Packet Received From: %s, IPSC Peer %s, Destination %s', _network, 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)
        if _ts == 0:
            _TS = 'TS1'
        elif _ts == 1:
            _TS = 'TS2'
        
        now = time()                                # Mark packet arrival time -- we'll need this for call contention handling 
        
        for rule in RULES[_network]['GROUP_VOICE']:
            _target = rule['DST_NET']               # Shorthand to reduce length and make it easier to read
            _status = networks[_target].IPSC_STATUS # Shorthand to reduce length and make it easier to read

            # Matching for rules is against the Destination Group in the SOURCE packet (SRC_GROUP)
            #if rule['SRC_GROUP'] == _dst_group and rule['SRC_TS'] == _ts:
            #if BRIDGES:
            if (rule['SRC_GROUP'] == _dst_group and rule['SRC_TS'] == _ts) and (self.BRIDGE == True or networks[_target].BRIDGE == True):
                
                if ((rule['DST_GROUP'] != _status[_TS]['RX_GROUP']) and ((now - _status[_TS]['RX_TIME']) < RULES[_network]['GROUP_HANGTIME'])):
                    if _burst_data_type == BURST_DATA_TYPE['VOICE_HEAD']:
                        logger.info('(%s) Call not bridged, target active or in group hangtime: IPSC %s, %s, TGID%s', _network, _target, _TS, int_id(rule['DST_GROUP']))
                    return
                    
                if ((rule['DST_GROUP'] != _status[_TS]['TX_GROUP']) and ((now - _status[_TS]['TX_TIME']) < RULES[_network]['GROUP_HANGTIME'])):
                    if _burst_data_type == BURST_DATA_TYPE['VOICE_HEAD']:
                        logger.info('(%s) Call not bridged, target in group hangtime: IPSC %s, %s, TGID%s', _network, _target, _TS, int_id(rule['DST_GROUP']))
                    return

                if (rule['DST_GROUP'] == _status[_TS]['TX_GROUP']) and (_src_sub != _status[_TS]['TX_SRC_SUB']) and ((now - _status[_TS]['TX_TIME']) < TS_CLEAR_TIME):
                    if _burst_data_type == BURST_DATA_TYPE['VOICE_HEAD']:
                        logger.info('(%s) Call not bridged, call bridge in progress from %s, target: IPSC %s, %s, TGID%s', _network, int_id(_src_sub), _target, _TS, int_id(rule['DST_GROUP']))
                    return

                if (rule['DST_GROUP'] == _status[_TS]['RX_GROUP']) and ((now - _status[_TS]['RX_TIME']) < TS_CLEAR_TIME):
                    if _burst_data_type == BURST_DATA_TYPE['VOICE_HEAD']:
                        logger.info('(%s) Call not bridged, matching call already active on target: IPSC %s, %s, TGID%s', _network, _target, _TS, int_id(rule['DST_GROUP']))
                    return
                       
                _tmp_data = _data
                # Re-Write the IPSC SRC to match the target network's ID
                _tmp_data = _tmp_data.replace(_peerid, NETWORK[_target]['LOCAL']['RADIO_ID'])
                # Re-Write the destination Group ID
                _tmp_data = _tmp_data.replace(_dst_group, rule['DST_GROUP'])
            
                # Re-Write IPSC timeslot value
                _call_info = int_id(_data[17:18])
                if rule['DST_TS'] == 0:
                    _call_info &= ~(1 << 5)
                elif rule['DST_TS'] == 1:
                    _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 rule['DST_TS'] == 0:
                        _burst_data_type = BURST_DATA_TYPE['SLOT1_VOICE']
                    elif rule['DST_TS'] == 1:
                        _burst_data_type = BURST_DATA_TYPE['SLOT2_VOICE']
                    _tmp_data = _tmp_data[:30] + _burst_data_type + _tmp_data[31:]
            
                # Calculate and append the authentication hash for the target network... if necessary
                if NETWORK[_target]['LOCAL']['AUTH_ENABLED']:
                    _tmp_data = self.hashed_packet(NETWORK[_target]['LOCAL']['AUTH_KEY'], _tmp_data)
                # Send the packet to all peers in the target IPSC
                networks[_target].send_to_ipsc(_tmp_data)

                _status[_TS]['TX_GROUP'] = _dst_group
                _status[_TS]['TX_TIME'] = now
                _status[_TS]['TX_SRC_SUB'] = _src_sub

        # Mark the group and time that a packet was recieved
        self.IPSC_STATUS[_TS]['RX_GROUP'] = _dst_group
        self.IPSC_STATUS[_TS]['RX_TIME'] = now
예제 #30
0
파일: log.py 프로젝트: KD8EYF/DMRlink
 def private_data(self, _network, _src_sub, _dst_sub, _ts, _end, _peerid, _data):    
     _dst_sub    = get_info(int_id(_dst_sub), subscriber_ids)
     _peerid     = get_info(int_id(_peerid), peer_ids)
     _src_sub    = get_info(int_id(_src_sub), subscriber_ids)
     print('({}) Private Data Packet Received From: {} To: {}' .format(_network, _src_sub, _dst_sub))
예제 #31
0
파일: bridge.py 프로젝트: n8ohu/DMRlink
    def private_data(self, _network, _src_sub, _dst_sub, _ts, _end, _peerid, _data):    
        logger.debug('(%s) Private Data Packet Received From: %s, IPSC Peer %s, Destination %s', _network, int_id(_src_sub), int_id(_peerid), int_id(_dst_sub))
        
        for target in RULES[_network]['PRIVATE_DATA']:
                   
            if self.BRIDGE == True or networks[target].BRIDGE == True:
                _tmp_data = _data
                # Re-Write the IPSC SRC to match the target network's ID
                _tmp_data = _tmp_data.replace(_peerid, NETWORK[target]['LOCAL']['RADIO_ID'])

                # Calculate and append the authentication hash for the target network... if necessary
                if NETWORK[target]['LOCAL']['AUTH_ENABLED']:
                    _tmp_data = self.hashed_packet(NETWORK[target]['LOCAL']['AUTH_KEY'], _tmp_data)
                # Send the packet to all peers in the target IPSC
                networks[target].send_to_ipsc(_tmp_data)
예제 #32
0
    def private_data(self, _network, _src_sub, _dst_sub, _ts, _end, _peerid, _data):    
        logger.debug('(%s) Private Data Packet Received From: %s, IPSC Peer %s, Destination %s', _network, int_id(_src_sub), int_id(_peerid), int_id(_dst_sub))
        
        for rule in RULES[_network]['PRIVATE_DATA']:
            _target = rule                          # Shorthand to reduce length and make it easier to read
       
            if self.BRIDGE == True or networks[_target].BRIDGE == True:
                _tmp_data = _data
                # Re-Write the IPSC SRC to match the target network's ID
                _tmp_data = _tmp_data.replace(_peerid, NETWORK[_target]['LOCAL']['RADIO_ID'])

                # Calculate and append the authentication hash for the target network... if necessary
                if NETWORK[_target]['LOCAL']['AUTH_ENABLED']:
                    _tmp_data = self.hashed_packet(NETWORK[_target]['LOCAL']['AUTH_KEY'], _tmp_data)
                # Send the packet to all peers in the target IPSC
                networks[_target].send_to_ipsc(_tmp_data)
예제 #33
0
 def private_voice(self, _network, _src_sub, _dst_sub, _ts, _end, _peerid, _data):
     if id == _dst_sub and _ts in ts:
         if not _end:
             if not self.CALL_DATA:
                 print('({}) Recording transmission from subscriber: {}' .format(_network, int_id(_src_sub)))
             self.CALL_DATA.append(_data)
         if _end:
             self.CALL_DATA.append(_data)
             print('({}) Transmission ended, writing to disk: {}' .format(_network, filename))
             pickle.dump(self.CALL_DATA, open(filename, 'wb'))
             reactor.stop()
             print('Recording created, program terminating')
예제 #34
0
파일: bridge.py 프로젝트: n8ohu/DMRlink
    def group_voice(self, _network, _src_sub, _dst_group, _ts, _end, _peerid, _data):
        logger.debug('(%s) Group Voice Packet Received From: %s, IPSC Peer %s, Destination %s', _network, 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)
        if _ts == 0:
            _TS = 'TS1'
        elif _ts == 1:
            _TS = 'TS2'
        
        now = time()                                # Mark packet arrival time -- we'll need this for call contention handling 
        
        for rule in RULES[_network]['GROUP_VOICE']:
            _target = rule['DST_NET']               # Shorthand to reduce length and make it easier to read
            _status = networks[_target].IPSC_STATUS # Shorthand to reduce length and make it easier to read

            # Matching for rules is against the Destination Group in the SOURCE packet (SRC_GROUP)
            #if rule['SRC_GROUP'] == _dst_group and rule['SRC_TS'] == _ts:
            #if BRIDGES:
            if (rule['SRC_GROUP'] == _dst_group and rule['SRC_TS'] == _ts) and (self.BRIDGE == True or networks[_target].BRIDGE == True):
                if RULES[_network]['TRUNK'] == False:
                    if ((rule['DST_GROUP'] != _status[_TS]['RX_GROUP']) and ((now - _status[_TS]['RX_TIME']) < RULES[_network]['GROUP_HANGTIME'])):
                        if _burst_data_type == BURST_DATA_TYPE['VOICE_HEAD']:
                            logger.info('(%s) Call not bridged, target active or in group hangtime: IPSC %s, %s, TGID%s', _network, _target, _TS, int_id(rule['DST_GROUP']))
                        continue
                    
                    if ((rule['DST_GROUP'] != _status[_TS]['TX_GROUP']) and ((now - _status[_TS]['TX_TIME']) < RULES[_network]['GROUP_HANGTIME'])):
                        if _burst_data_type == BURST_DATA_TYPE['VOICE_HEAD']:
                            logger.info('(%s) Call not bridged to destination on TGID %s, target in group hangtime: IPSC %s, %s, TGID%s', _network, int_id(_status[_TS]['TX_GROUP']), _target, _TS, int_id(rule['DST_GROUP']))
                        continue

                    if (rule['DST_GROUP'] == _status[_TS]['TX_GROUP']) and (_src_sub != _status[_TS]['TX_SRC_SUB']) and ((now - _status[_TS]['TX_TIME']) < TS_CLEAR_TIME):
                        if _burst_data_type == BURST_DATA_TYPE['VOICE_HEAD']:
                            logger.info('(%s) Call not bridged, call bridge in progress from %s, target: IPSC %s, %s, TGID%s', _network, int_id(_src_sub), _target, _TS, int_id(rule['DST_GROUP']))
                        continue

                    if (rule['DST_GROUP'] == _status[_TS]['RX_GROUP']) and ((now - _status[_TS]['RX_TIME']) < TS_CLEAR_TIME):
                        if _burst_data_type == BURST_DATA_TYPE['VOICE_HEAD']:
                            logger.info('(%s) Call not bridged, matching call already active on target: IPSC %s, %s, TGID%s', _network, _target, _TS, int_id(rule['DST_GROUP']))
                        continue
                       
                _tmp_data = _data
                # Re-Write the IPSC SRC to match the target network's ID
                _tmp_data = _tmp_data.replace(_peerid, NETWORK[_target]['LOCAL']['RADIO_ID'])
                # Re-Write the destination Group ID
                _tmp_data = _tmp_data.replace(_dst_group, rule['DST_GROUP'])
            
                # Re-Write IPSC timeslot value
                _call_info = int_id(_data[17:18])
                if rule['DST_TS'] == 0:
                    _call_info &= ~(1 << 5)
                elif rule['DST_TS'] == 1:
                    _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 rule['DST_TS'] == 0:
                        _burst_data_type = BURST_DATA_TYPE['SLOT1_VOICE']
                    elif rule['DST_TS'] == 1:
                        _burst_data_type = BURST_DATA_TYPE['SLOT2_VOICE']
                    _tmp_data = _tmp_data[:30] + _burst_data_type + _tmp_data[31:]
            
                # Calculate and append the authentication hash for the target network... if necessary
                if NETWORK[_target]['LOCAL']['AUTH_ENABLED']:
                    _tmp_data = self.hashed_packet(NETWORK[_target]['LOCAL']['AUTH_KEY'], _tmp_data)
                # Send the packet to all peers in the target IPSC
                networks[_target].send_to_ipsc(_tmp_data)

                _status[_TS]['TX_GROUP'] = rule['DST_GROUP']
                _status[_TS]['TX_TIME'] = now
                _status[_TS]['TX_SRC_SUB'] = _src_sub

        # Mark the group and time that a packet was recieved
        self.IPSC_STATUS[_TS]['RX_GROUP'] = _dst_group
        self.IPSC_STATUS[_TS]['RX_TIME'] = now 
예제 #35
0
파일: log.py 프로젝트: KD8EYF/DMRlink
 def group_data(self, _network, _src_sub, _dst_sub, _ts, _end, _peerid, _data):    
     _dst_sub    = get_info(int_id(_dst_sub), talkgroup_ids)
     _peerid     = get_info(int_id(_peerid), peer_ids)
     _src_sub    = get_info(int_id(_src_sub), subscriber_ids)
     print('({}) Group Data Packet Received From: {}' .format(_network, _src_sub))
예제 #36
0
    def group_voice(self, _network, _src_sub, _dst_group, _ts, _end, _peerid,
                    _data):
        if _end:
            _self_peer = NETWORK[_network]['LOCAL']['RADIO_ID']
            _self_src = _self_peer[1:]

            if (_peerid == _self_peer) or (_src_sub == _self_src):
                logger.error(
                    '(%s) Just received a packet that appears to have been originated by us. PeerID: %s Subscriber: %s TS: %s, TGID: %s',
                    _network, int_id(_peerid), int_id(_src_sub),
                    int(_ts) + 1, int_id(_dst_group))
                return

            if trigger == False:
                if (_ts == 0 and _dst_group not in trigger_groups_1) or (
                        _ts == 1 and _dst_group not in trigger_groups_2):
                    return
            else:
                if (_ts == 0 and _dst_group in trigger_groups_1) or (
                        _ts == 1 and _dst_group in trigger_groups_2):
                    return

            logger.info(
                '(%s) Event ID: %s - Playback triggered from SourceID: %s, TS: %s, TGID: %s, PeerID: %s',
                _network, self.event_id, int_id(_src_sub), _ts + 1,
                int_id(_dst_group), int_id(_peerid))

            # Determine the type of voice packet this is (see top of file for possible types)
            _burst_data_type = _data[30]

            time.sleep(2)
            self.CALL_DATA = pickle.load(open(filename, 'rb'))
            logger.info('(%s) Event ID: %s - Playing back file: %s', _network,
                        self.event_id, filename)

            for i in self.CALL_DATA:
                _tmp_data = i

                # re-Write the peer radio ID to that of this program
                _tmp_data = _tmp_data.replace(_peerid, _self_peer)
                # re-Write the source subscriber ID to that of this program
                _tmp_data = _tmp_data.replace(_src_sub, _self_src)
                # Re-Write the destination Group ID
                _tmp_data = _tmp_data.replace(_tmp_data[9:12], _dst_group)

                # Re-Write IPSC timeslot value
                _call_info = int_id(_tmp_data[17:18])
                if _ts == 0:
                    _call_info &= ~(1 << 5)
                elif _ts == 1:
                    _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']:
                    # Re-Write timeslot if necessary...
                    if _ts == 0:
                        _burst_data_type = BURST_DATA_TYPE['SLOT1_VOICE']
                    elif _ts == 1:
                        _burst_data_type = BURST_DATA_TYPE['SLOT2_VOICE']
                    _tmp_data = _tmp_data[:30] + _burst_data_type + _tmp_data[
                        31:]

                _tmp_data = self.hashed_packet(
                    NETWORK[_network]['LOCAL']['AUTH_KEY'], _tmp_data)
                # Send the packet to all peers in the target IPSC
                self.send_to_ipsc(_tmp_data)
                time.sleep(0.06)
            self.CALL_DATA = []
            logger.info('(%s) Event ID: %s - Playback Completed', _network,
                        self.event_id)
            self.event_id = self.event_id + 1
예제 #37
0
파일: rcm.py 프로젝트: ebook/DMRlink
 def repeater_wake_up(self, _network, _data):
     _source = _data[1:5]
     _source_dec = int_id(_source)
     _source_name = get_info(_source_dec, peer_ids)
     print('({}) Repeater Wake-Up Packet Received: {} ({})' .format(_network, _source_name, _source_dec))