# CASpy - Python implementation of DVB Simulcrypt CAS
# Currently, only implement EMM Generator (EMMG)
# Implementing DVB-Simulcrypt message :
import binascii
import socket
import ctypes
from time import sleep
import math
# Utility functions, to allow for serialization of the ctypes.Structure classes
def serialize(ctypesObj):
"""
FAQ: How do I copy bytes to Python from a ctypes.Structure?
"""
return buffer(ctypesObj)[:]
def deserialize(ctypesObj, inputBytes):
"""
FAQ: How do I copy bytes to a ctypes.Structure from Python?
"""
fit = min(len(inputBytes), ctypes.sizeof(ctypesObj))
ctypes.memmove(ctypes.addressof(ctypesObj), inputBytes, fit)
INPUT_BUFFER_LENGTH = 1024 # Units : [Bytes]. Input buffer size of received TCP messages
SEND_EMM_PERIOD_TIME = 50e-3 # Units : [Number of Seconds] / [IP packet]
SEND_EMM_FREQUENCY = 1.0 / SEND_EMM_PERIOD_TIME # Units : [Number of IP Packets] / [Sec]
BYTE_TO_BIT_SCALE = 8
KBPS_TO_BPS_SCALE = 1000.0
BPS_TO_KBPS_SCALE = 0.001
#EMM_DUMMY_DATA = binascii.unhexlify('01B040FFFFC7000009160500E03213012014030078001403007C0014030FFF4009040602E0C109040D01E1F409110500E0AB130120140300E800140300E8107A38F9E2')
# ****************************************************
# DVB Simulcrypt messages semantic
# ****************************************************
simulcrypt_protocol_version = 0x02
# Parameters type value according to Simulcrypt standard, 6.22 Table 5 - Parameters :
client_id_type = 0x0001
client_id_length = 4
section_TSpkt_flag_type = 0x0002
section_TSpkt_flag_length = 1
data_channel_id_type = 0x0003
data_channel_id_length = 2
data_stream_id_type = 0x0004
data_stream_id_length = 2
datagram_type = 0x0005 # Parameter length : Variable
bandwidth_type = 0x0006 # Units: kbit/s
bandwidth_length = 2
data_type_type = 0x0007
data_type_length = 1
data_id_type = 0x0008
data_id_length = 2
error_status_type = 0x7000 # See clause 6.2.6
error_status_length = 2
# According to 6.4, 6.5 - Messages :
Channel_setup_message_Type = 0x0011
Channel_test_message_Type = 0x0012
Channel_status_message_Type = 0x0013
Channel_close_message_Type = 0x0014
Channel_error_message_Type = 0x0015
Stream_setup_message_Type = 0x0111
Stream_test_message_Type = 0x0112
Stream_status_message_Type = 0x0113
Stream_close_request_message_Type = 0x0114
Stream_close_response_message_Type = 0x0115
Stream_error_message_Type = 0x0116
Stream_BW_request_message_Type = 0x0117
Stream_BW_allocation_message_Type = 0x0118
Data_provision_messageType = 0x0211
# ****************************************************
# SIMULCRYPT TLV CLASS
# ****************************************************
class CMessageHeader (ctypes.BigEndianStructure):
"""
message_header
"""
_pack_ = 1
_length_ = 5
_fields_ = [("protocol_version", ctypes.c_ubyte),
("message_type", ctypes.c_ushort),
("message_length", ctypes.c_ushort)]
class CTypeLength (ctypes.BigEndianStructure):
"""
Type Length, of the TLV struct
"""
_pack_ = 1
_length_ = 4
_fields_ = [("param_type", ctypes.c_ushort),
("param_length", ctypes.c_ushort)]
class CByteParam (ctypes.BigEndianStructure):
"""
One byte unsigned parameter
"""
_pack_ = 1
_length_ = 5
_fields_ = [("param_type", ctypes.c_ushort),
("param_length", ctypes.c_ushort),
("param_value", ctypes.c_ubyte)]
class CShortParam (ctypes.BigEndianStructure):
"""
Two byte unsigned parameter
"""
_pack_ = 1
_length_ = 6
_fields_ = [("param_type", ctypes.c_ushort),
("param_length", ctypes.c_ushort),
("param_value", ctypes.c_ushort)]
class CLongParam (ctypes.BigEndianStructure):
"""
Four byte unsigned parameter
"""
_pack_ = 1
_length_ = 8
_fields_ = [("param_type", ctypes.c_ushort),
("param_length", ctypes.c_ushort),
("param_value", ctypes.c_ulong)]
# ****************************************************
# EMMG CLASS
# ****************************************************
class CEMMG:
"""
Template for EMMG Simulator
"""
def __init__( self,
client_id, # #1
section_TSpkt_flag, # #2
data_channel_id, # #3
data_stream_id, # #4
bandwidth, # #5 # Unit : Kbps
data_id, # #6
data_type, # #7
inputFile): # #8
"""
These 7 parameters (excluding the actual data) form a single EMM stream.
One channel, One stream, One data id .
"""
# #1
self.client_id = CLongParam(client_id_type,
client_id_length,
client_id)
# #2
self.section_TSpkt_flag = CByteParam(section_TSpkt_flag_type,
section_TSpkt_flag_length,
section_TSpkt_flag)
# #3
self.data_channel_id = CShortParam(data_channel_id_type,
data_channel_id_length,
data_channel_id)
# #4
self.data_stream_id = CShortParam(data_stream_id_type,
data_stream_id_length,
data_stream_id)
# #6
self.data_id = CShortParam(data_id_type,
data_id_length,
data_id)
# #7
self.data_type = CByteParam(data_type_type,
data_type_length,
data_type)
#8
#Initialize members
self.Section = 0
self.IpEmmSectionPerCycle = 0
self.IpEmmSection = 0
self.IpEmmSectionLen = 0
self.dataTypeLength = 0
self._buildIpEmm_(inputFile, bandwidth)
#5
#Initialize members
self.minimumBPS = 0
self.ReqBWfromMux = 0
self.requestBW = 0
self._buildReqBWfromMux_()
# DEBUG PRINTS
print 'Section file \"%s\" length %d, will be sent at %d mSec per cycle ' % (inputFile, len(self.Section), SEND_EMM_PERIOD_TIME * KBPS_TO_BPS_SCALE)
print 'Minimum bitrate for this section (one section per cycle) : %.3f Kbps ' % (self.minimumBPS * BPS_TO_KBPS_SCALE)
print 'User requested bandwidth %d Kbps, which is %d sections per cycle, %.3f Kbps ' % (bandwidth, self.IpEmmSectionPerCycle, (self.minimumBPS * self.IpEmmSectionPerCycle * BPS_TO_KBPS_SCALE))
print 'Actual Requested Bandwidth from Multiplexer will be %d Kbps (%d sections per cycle)' % (self.ReqBWfromMux, (self.IpEmmSectionPerCycle + 1))
def _buildIpEmm_ (self, inputFile, bandwidth):
"""
Build data segment sent to TCP each SEND_EMM_PERIOD_TIME seconds
EMMG sends EMMs every fixed cycle time : SEND_EMM_PERIOD_TIME
Hence, the actual bitrate is determined by the number of sections being sent each time.
Calculation of the number of EMM sections each cycle is done in EmmSecPerCycle
"""
fd = open(inputFile, 'rb')
self.Section = fd.read()
fd.close()
self.IpEmmSectionPerCycle = self._calcNumberSectionsPerCycle_(bandwidth, len(self.Section))
self.IpEmmSection = self.Section * self.IpEmmSectionPerCycle
self.IpEmmSectionLen = len(self.IpEmmSection)
self.dataTypeLength = CTypeLength (datagram_type,
self.IpEmmSectionLen)
def _buildReqBWfromMux_ (self):
"""
Build requested BW from Multiplexer
"""
self.minimumBPS = SEND_EMM_FREQUENCY * len(self.Section) * BYTE_TO_BIT_SCALE
self.ReqBWfromMux = int( self.minimumBPS * (self.IpEmmSectionPerCycle + 1) * BPS_TO_KBPS_SCALE )
self.requestBW = CShortParam(bandwidth_type,
bandwidth_length,
self.ReqBWfromMux)
def _calcNumberSectionsPerCycle_ (self, requiredBW, sectionLength):
"""
Calculate the number of sections needed to be transmitted each cycle of SEND_EMM_PERIOD_TIME seconds,
given requiredBW in Kbps
"""
SectionPerCycle = ((requiredBW * KBPS_TO_BPS_SCALE) * SEND_EMM_PERIOD_TIME) / (sectionLength * BYTE_TO_BIT_SCALE)
SectionPerCycle = int (math.ceil(SectionPerCycle)) # Round up and cast to int the number of EMM sections being transmitted per cycle
return SectionPerCycle
def updateIpEmm (self, inputFile, requiredBW):
"""
Update IP Emm length according to new requiredBW and new file.
This method DOES NOT negotiate with Mux new BW Threshold, if requiredBW exceeds present threshold
"""
self._buildIpEmm_(inputFile, requiredBW)
def prepare_channel_setup_Msg (self):
"""
Prepares and packs the emm_channel_setup message
"""
msgBody = serialize(self.client_id) + \
serialize(self.data_channel_id) + \
serialize(self.section_TSpkt_flag)
msgHeader = serialize(CMessageHeader (simulcrypt_protocol_version, # DVB simulcrypt protocol : 0x02
Channel_setup_message_Type,
len(msgBody))) # Calculate total message length
totalMsg = msgHeader + msgBody
return totalMsg
def prepare_stream_setup_Msg (self):
"""
Prepares and packs the emm_stream_setup message
"""
msgBody = serialize(self.client_id) + \
serialize(self.data_channel_id) + \
serialize(self.data_stream_id) + \
serialize(self.data_id) + \
serialize(self.data_type)
msgHeader = serialize(CMessageHeader (simulcrypt_protocol_version, # DVB simulcrypt protocol : 0x02
Stream_setup_message_Type,
len(msgBody))) # Calculate total message length
totalMsg = msgHeader + msgBody
return totalMsg
def prepare_stream_BW_request_Msg (self):
"""
Prepares and packs the stream bandwidth request message
"""
msgBody = serialize(self.client_id) + \
serialize(self.data_channel_id) + \
serialize(self.data_stream_id) + \
serialize(self.requestBW)
msgHeader = serialize(CMessageHeader (simulcrypt_protocol_version, # DVB simulcrypt protocol : 0x02
Stream_BW_request_message_Type,
len(msgBody))) # Calculate total message length
totalMsg = msgHeader + msgBody
return totalMsg
def prepare_Provision_Data_Msg (self):
"""
Prepares and packs the Provision Data message
"""
msgBody = serialize(self.client_id) + \
serialize(self.data_channel_id) + \
serialize(self.data_stream_id) + \
serialize(self.data_id) + \
serialize(self.dataTypeLength) + \
self.IpEmmSection
msgHeader = serialize(CMessageHeader (simulcrypt_protocol_version, # DVB simulcrypt protocol : 0x02
Data_provision_messageType,
len(msgBody))) # Calculate total message length
totalMsg = msgHeader + msgBody
return totalMsg
def receiveMessage(self, strMsg):
"""
Parse buffer received from mux
"""
header = CMessageHeader(0,0,0)
paramTL = CTypeLength (0,0) # Parameter Type-Length values (from the trio TYPE-LENGTH-VALUE)
longParam = CLongParam (0,0,0)
shortParam = CShortParam (0,0,0)
byteParam = CByteParam (0,0,0)
JUSTIFY_LEN = 25
# Parse header
deserialize (header, strMsg)
if header.message_type == Channel_setup_message_Type :
print "Message type Channel_setup_message "
elif header.message_type == Channel_test_message_Type :
print "Message type Channel_test_message "
elif header.message_type == Channel_status_message_Type :
print "Message type Channel_status_message "
elif header.message_type == Channel_close_message_Type :
print "Message type Channel_close_message "
elif header.message_type == Channel_error_message_Type :
print "Message type Channel_error_message "
elif header.message_type == Stream_setup_message_Type :
print "Message type Stream_setup_message "
elif header.message_type == Stream_test_message_Type :
print "Message type Stream_test_message "
elif header.message_type == Stream_status_message_Type :
print "Message type Stream_status_message "
elif header.message_type == Stream_close_request_message_Type :
print "Message type Stream_close_request_message "
elif header.message_type == Stream_close_response_message_Type :
print "Message type Stream_close_response_message "
elif header.message_type == Stream_error_message_Type :
print "Message type Stream_error_message "
elif header.message_type == Stream_BW_request_message_Type :
print "Message type Stream_BW_request_message "
elif header.message_type == Stream_BW_allocation_message_Type :
print "Message type Stream_BW_allocation_message "
elif header.message_type == Data_provision_messageType :
print "Message type Data_provision_message "
print "Message Length : ".ljust(JUSTIFY_LEN), header.message_length
# Parse message body. Iterate on TLV structures
strMsg = strMsg[CMessageHeader._length_ : ]
while len(strMsg) > 0 :
deserialize(paramTL, strMsg)
if paramTL.param_type == client_id_type :
deserialize (longParam, strMsg)
print "Client id : ".ljust(JUSTIFY_LEN), "0x%X" % longParam.param_value
strMsg = strMsg [CLongParam._length_ : ]
elif paramTL.param_type == section_TSpkt_flag_type :
deserialize (byteParam, strMsg)
print "section TSpkt flag : ".ljust(JUSTIFY_LEN), byteParam.param_value
strMsg = strMsg [CByteParam._length_ : ]
elif paramTL.param_type == data_channel_id_type :
deserialize (shortParam, strMsg)
print "data channel id : ".ljust(JUSTIFY_LEN), shortParam.param_value
strMsg = strMsg [CShortParam._length_ : ]
elif paramTL.param_type == data_stream_id_type :
deserialize (shortParam, strMsg)
print "data stream id : ".ljust(JUSTIFY_LEN), shortParam.param_value
strMsg = strMsg [CShortParam._length_ : ]
elif paramTL.param_type == bandwidth_type :
deserialize (shortParam, strMsg)
print "bandwidth : ".ljust(JUSTIFY_LEN), shortParam.param_value
strMsg = strMsg [CShortParam._length_ : ]
elif paramTL.param_type == data_type_type :
deserialize (byteParam, strMsg)
print "data type : ".ljust(JUSTIFY_LEN), byteParam.param_value
strMsg = strMsg [CByteParam._length_ : ]
elif paramTL.param_type == data_id_type :
deserialize (shortParam, strMsg)
print "data id : ".ljust(JUSTIFY_LEN), shortParam.param_value
strMsg = strMsg [CShortParam._length_ : ]
elif paramTL.param_type == error_status_type :
deserialize (shortParam, strMsg)
print "error status : ".ljust(JUSTIFY_LEN), shortParam.param_value
strMsg = strMsg [CShortParam._length_ : ]
if __name__ == '__main__':
EMM_INPUT_FILE = r'D:\EmmgSimulator\section'
#--- Prepare EMMG
EMMG1 = CEMMG ( client_id = 0x00099999,
section_TSpkt_flag = 0x0,
data_channel_id = 0x1,
data_stream_id = 0x32,
bandwidth = 20, # Units : Kbps. bandwidth request
data_id = 0x1,
data_type = 0x1,
inputFile = EMM_INPUT_FILE)
#--- Connect to Mux EMM TCP SERVER
muxEmmSocket = socket.socket()
host = '10.40.2.195'
port = 20000
muxEmmSocket.connect ((host, port))
print
print " CHANNEL SETUP"
print " *************"
#--- Send Channel Setup Message
sendMsg = EMMG1.prepare_channel_setup_Msg()
muxEmmSocket.send(sendMsg);
#--- Get Channel Status Message
muxEmmMsg = muxEmmSocket.recv(INPUT_BUFFER_LENGTH)
EMMG1.receiveMessage(muxEmmMsg)
print
print " STREAM SETUP"
print " ************"
#--- Send Stream Setup Message
sendMsg = EMMG1.prepare_stream_setup_Msg()
muxEmmSocket.send(sendMsg);
#--- Get Stream Status Message
muxEmmMsg = muxEmmSocket.recv(INPUT_BUFFER_LENGTH)
EMMG1.receiveMessage(muxEmmMsg)
print
print " Stream BW Allocation"
print " ********************"
#--- Send stream BW request Message
sendMsg = EMMG1.prepare_stream_BW_request_Msg()
muxEmmSocket.send(sendMsg);
#--- Get Stream BW allocation Message
muxEmmMsg = muxEmmSocket.recv(INPUT_BUFFER_LENGTH)
EMMG1.receiveMessage(muxEmmMsg)
print
print " Send provision Data"
print " *******************"
#--- Send stream BW request Message
sendMsg = EMMG1.prepare_Provision_Data_Msg()
counter = 0
while True :
# Send TCP message with the required EMM
muxEmmSocket.send(sendMsg);
counter += 1
# Change EMM bitrate
if counter == 400:
EMMG1.updateIpEmm(EMM_INPUT_FILE, 60)
sendMsg = EMMG1.prepare_Provision_Data_Msg()
# Change EMM bitrate
elif counter == 800:
EMMG1.updateIpEmm(EMM_INPUT_FILE, 150)
sendMsg = EMMG1.prepare_Provision_Data_Msg()
# Change EMM bitrate
elif counter == 1200:
EMMG1.updateIpEmm(EMM_INPUT_FILE, 20)
sendMsg = EMMG1.prepare_Provision_Data_Msg()
# Wait for SEND_EMM_PERIOD_TIME before sending again
sleep (SEND_EMM_PERIOD_TIME)
# Print statistics
if counter == 8000:
break
elif (counter % 80) == 0 :
print "Sent " , counter, " packets."
print "Message length : %d" % len(sendMsg)
