def open(self):
or_valueerror(self.sock is None)
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.sock.bind(self.local_address)
self.logger.debug('socket opened')
def from_data(cls, data):
or_valueerror(len(data) == 11)
src_callsign, src_module, dest_module, _ = struct.unpack('8sccB', data)
src_callsign = DSTARCallsign(src_callsign)
src_module = DSTARModule(src_module)
dest_module = DSTARModule(dest_module)
or_valueerror(str(dest_module) == ' ')
return cls(src_callsign, src_module)
def open(self):
or_valueerror(self.f is None)
try:
self.f = open(self.name, 'a+b')
except Exception as e:
self.logger.error('can not open file: %s', str(e))
return False
self.logger.debug('opened file %s', self.name)
return True
def __init__(self, callsign):
or_valueerror(len(callsign) > 3)
or_valueerror(
set(callsign[:3]).issubset(string.ascii_letters + string.digits))
or_valueerror(not callsign[:3].isdigit())
or_valueerror(
set(callsign[3:]).issubset(string.ascii_letters + string.digits +
' '))
or_valueerror(len(callsign) <= 8)
self.callsign = callsign.upper()
def write(self, data):
or_valueerror(self.sock)
self.logger.debug('write %d bytes to %s: %s', len(data),
self.remote_address, repr(data))
length = self.sock.sendto(data, self.remote_address)
self.logger.debug('wrote %d bytes', length)
if length != len(data):
return False
return True
def from_data(cls, data):
if len(data) == 29:
or_valueerror(data[:2] == '\x1d\x80')
dv_frame = DVFramePacket.from_data(data[2:])
return cls(dv_frame)
elif len(data) == 32:
or_valueerror(data[:2] == '\x20\x80')
dv_frame = DVFramePacket.from_data(data[2:29])
if not dv_frame.is_last:
dv_frame.packet_id |= 64
return cls(dv_frame)
else:
raise ValueError
def from_data(cls, data):
or_valueerror(len(data) == 11)
src_callsign, src_module, dest_module, src_revision = struct.unpack(
'8sccB', data)
src_callsign = DSTARCallsign(src_callsign)
src_module = DSTARModule(src_module)
dest_module = DSTARModule(dest_module)
or_valueerror(str(dest_module) != ' ')
if src_revision == 11:
revision = 1
elif (str(src_callsign).startswith('XRF')):
revision = 2
else:
revision = 0
return cls(src_callsign, src_module, dest_module, revision)
def from_data(cls, data):
or_valueerror(len(data) == 56)
or_valueerror(data[:4] == 'DSVT')
or_valueerror(data[4] == '\x10')
or_valueerror(data[8] == '\x20')
band_1, band_2, band_3, stream_id = struct.unpack('<BBBH', data[9:14])
dstar_header = DSTARHeader.from_data(data[15:])
return cls(band_1, band_2, band_3, stream_id, dstar_header)
def from_data(cls, data):
or_valueerror(len(data) == 27)
or_valueerror(data[:4] == 'DSVT')
or_valueerror(data[4] == '\x20')
or_valueerror(data[8] == '\x20')
band_1, band_2, band_3, stream_id, packet_id = struct.unpack(
'<BBBHB', data[9:15])
dstar_frame = DSTARFrame.from_data(data[15:])
return cls(band_1, band_2, band_3, stream_id, packet_id, dstar_frame)
def read(self, length=1024):
or_valueerror(self.sock)
# Check that the recvfrom() won't block
readable, writable, exceptional = select.select(
[self.sock], [], [], 0) # Return immediately
if not readable:
return None
data, address = self.sock.recvfrom(length)
self.logger.debug('read %d bytes from %s: %s', len(data), address,
repr(data))
# Check if the data is for us, only check the IP address now (used to include port number too)
if self.remote_address.host != address[0]:
return None
return data
def from_data(cls, data):
or_valueerror(len(data) == 41)
header, crc = data[:39], data[39:]
flag_1, \
flag_2, \
flag_3, \
repeater_1_callsign, \
repeater_2_callsign, \
ur_callsign, \
my_callsign, \
my_suffix = struct.unpack('BBB8s8s8s8s4s', header)
repeater_1_callsign = DSTARCallsign(repeater_1_callsign)
repeater_2_callsign = DSTARCallsign(repeater_2_callsign)
ur_callsign = DSTARCallsign(ur_callsign)
my_callsign = DSTARCallsign(my_callsign)
my_suffix = DSTARSuffix(my_suffix)
checksum = CCITTChecksum()
checksum.update(header)
# xlxd may rewrite header callsigns, without recomputing the checksum
# or_valueerror(crc == checksum.result())
return cls(flag_1, flag_2, flag_3, repeater_1_callsign,
repeater_2_callsign, ur_callsign, my_callsign, my_suffix)
def from_data(cls, data):
or_valueerror(len(data) == 14)
src_callsign, src_module, dest_module, nack = struct.unpack(
'8scc4s', data)
src_callsign = DSTARCallsign(src_callsign)
src_module = DSTARModule(src_module)
dest_module = DSTARModule(dest_module)
or_valueerror(str(dest_module) != ' ')
or_valueerror(nack == 'NAK\x00')
return cls(src_callsign, src_module, dest_module)
def from_data(cls, data):
# Same size with disconnect
# if (len(data) == 11):
# raise NotImplementedError
or_valueerror(len(data) == 14)
src_callsign, src_module, dest_module, ack = struct.unpack(
'8scc4s', data)
src_callsign = DSTARCallsign(src_callsign)
src_module = DSTARModule(src_module)
dest_module = DSTARModule(dest_module)
or_valueerror(str(dest_module) != ' ')
or_valueerror(ack == 'ACK\x00')
return cls(src_callsign, src_module, dest_module,
1) # XXX Could it be revision 0?
def read(self):
self.f.seek(0)
stream = []
magic, count = struct.unpack('<6sI', self.f.read(10))
or_valueerror(magic == 'DVTOOL')
for i in xrange(count):
size, = struct.unpack('<H', self.f.read(2))
data = self.f.read(size)
if i == 0:
or_valueerror(size == 56)
packet = DVHeaderPacket.from_data(data)
else:
or_valueerror(size == 27)
packet = DVFramePacket.from_data(data)
stream.append(packet)
self.logger.info('read a stream of %s packets from %s', len(stream),
self.name)
return stream
def from_data(cls, data):
or_valueerror(len(data) == 12)
dvcodec, dvdata = data[:9], data[9:]
return cls(dvcodec, dvdata)
def __init__(self, suffix):
or_valueerror(
set(suffix).issubset(string.ascii_letters + string.digits + ' '))
or_valueerror(len(suffix) <= 4)
self.suffix = suffix.upper()
def from_data(cls, data):
or_valueerror(len(data) == 9)
src_callsign, _ = struct.unpack('8sc', data)
src_callsign = DSTARCallsign(src_callsign)
return cls(src_callsign) # XXX Get module?
def __init__(self, module):
or_valueerror(len(module) == 1)
or_valueerror(set(module).issubset(string.ascii_letters + ' '))
self.module = module.upper()
def from_data(cls, data):
or_valueerror(len(data) == 28)
login, callsign, _, serial = struct.unpack('4s8s8s8s', data[4:])
or_valueerror(login == '\x1c\xc0\x04\x00')
callsign = DSTARCallsign(callsign)
return cls(callsign, serial)
def from_data(cls, data):
or_valueerror(len(data) == 58)
or_valueerror(data[:2] == '\x3a\x80')
dv_header = DVHeaderPacket.from_data(data[2:])
return cls(dv_header)
def from_data(cls, data):
or_valueerror(len(data) == len(cls.data))
or_valueerror(data == cls.data)
return cls()