def findSimpleElementLocation(self, avpCode, msgSize):
codeFound = False
size = self.nwBuffer.tell() #bytes
o_ParsedData = ParsedData()
while (size < msgSize) and not codeFound:
#print "DEBUG: {0} : {1} : {2}".format(size, msgSize, self.nwBuffer.tell())
# read the AVP Code
fmt = struct.Struct('>I')
try:
(avp,) = fmt.unpack(self.nwBuffer.read(4))
except Exception, e:
print "ERROR: Major formatting Issue {0}. Exception : {1}".format(avpCode, str(e))
return o_ParsedData
if avp == avpCode:
codeFound = True
## Flags And Length
[avpLen, avpFlags] = utils.getFlagAndLength(self.nwBuffer.read(4))
avpLenPadded = avpLen + utils.calculatePadding(avpLen)
size += 8
if codeFound:
o_ParsedData.isParsed = True
o_ParsedData.avpSize = avpLen
o_ParsedData.padding = utils.calculatePadding(avpLen)
if (utils.existVendorID(avpFlags)):
# read vendor-id
(vendorID,) = fmt.unpack(self.nwBuffer.read(4))
o_ParsedData.vendorID = vendorID
size += 4
## Set the network buffer to the data.
## It's already set to data due to above read.
## So, we can return safely from here
codeFound = False
return o_ParsedData
else:
unwanted = self.nwBuffer.read(avpLenPadded - 8) ## (8 bytes is already read)
size += (avpLenPadded - 8)
def setFlags(self, avpFlags):
if utils.existVendorID(avpFlags):
self.avp['Vendor-ID'] = 1
else:
self.avp['Vendor-ID'] = 0
self.clrVendorBit()
if utils.existMandatory(avpFlags):
self.avp['Mandatory'] = 1
self.setMandatoryBit()
else:
self.avp['Mandatory'] = 0
self.clrMandatoryBit()
if utils.existPersistent(avpFlags):
self.avp['Protected'] = 1
self.setEncryptionBit()
else:
self.avp['Protected'] = 0
self.clrEncryptionBit()
def atomHandler(self, avpName, avpValue, fileRec = None):
if fileRec:
index = self.getIndexFromHeader(avpName)
if index is not None:
#avpValue = utils.format(avpName, fileRec[index].strip()) #what if we want spaces ?
avpValue = utils.format(avpName, fileRec[index])
try:
self.formatter.addElement(avpName, avpValue)
except Exception, e:
print "ERROR for AVP {0}".format(avpName)
print "Exception:\n{0}".format(str(e))
def initParser(self):
if self.fileName:
try:
fd = open(self.fileName, "rb")
except Exception, e:
print "ERROR: file not loaded. Exception = {0}".format(str(e))
# Read first 4 bytes of diameter event(which is part of 20 byte header)
[msgLen, Version] = utils.getFlagAndLength(fd.read(4))
# set file descriptor to start of file
fd.seek(0)
data = fd.read(msgLen)
fd.close()
def __init__(self, File = None, eventType = None):
self.fileName = File
self.eventType = eventType
self.parser = None
self.event = evtStruct.eventStructure[eventType]
self.avpObject = dict()
self.code2Name = dict()
self.decodeBF = dict() ## key = data_type ; value = Function
self.decodeBF = utils.bindDecodingFunc(self.decodeBF)
self.mapCode2Name()
self.initParser()
def getElement(self, avpName = None, msgSize = None):
if not msgSize:
msgSize = self.nwEventSize
if avpName:
avpCode = utils.getAVPCode(avpName)
if avpCode:
return self.findSimpleElementLocation(avpCode, msgSize)
else:
print "ERROR: AVP code not found for {0}".format(avpName)
return False
else:
print "ERROR: AVP Name not provided {0}".format(avpName)
return False
return True
def groupHandler(self, avpName, child, fileRec = None):
grpAvp = Node.DiameterGroup(avpName)
for name, value in child.iteritems():
if isinstance(value, dict):
grpAVP_N = self.groupHandler(name, value, fileRec)
try:
grpAvp.addItem(grpAVP_N)
except Exception, e:
print "ERROR for AVP {0}".format(name)
print "Exception:\n{0}".format(str(e))
pass
else:
if fileRec:
index = self.getIndexFromHeader(name)
if index is not None:
value = utils.format(name, fileRec[index].strip())
try:
atmAvp = Node.DiameterAtom(name)
atmAvp.setContent(value)
grpAvp.addItem(atmAvp)
except Exception, e:
print "ERROR for AVP {0}".format(name)
print "Exception:\n{0}".format(str(e))
def bindEncodingFunc(self):
self.encodeBF = utils.bindEncodingFunc(self.encodeBF)
def stringEncoder(content):
padding = utils.calculatePadding(len(content))
packedData = struct.pack("{0}s{1}x".format(len(content), padding), str(content))
return [packedData, len(content), padding]
padding = utils.calculatePadding(len(content))
packedData = struct.pack("{0}s{1}x".format(len(content), padding), str(content))
return [packedData, len(content), padding]
def ipv4AddressEncoder(content):
import socket
try:
packedData = socket.inet_aton(content)
except Exception, e:
print "WARN: incorrect IP address: {0}".format(content)
packedData = socket.inet_aton("10.10.10.10")
return [packedData, 4, 0]
def ipv4AddressEncoderE164(content):
import socket
try:
ip = socket.inet_aton(content)
pack = struct.pack("!2B4s", 0, 1, ip).encode("hex")
except Exception, e:
print "WARN: incorrect IP address: {0}".format(content)
pack = socket.inet_aton("10.10.10.10")
pack = struct.pack("!2B4s", 0, 1, pack).encode("hex")
return [pack, len(pack), utils.calculatePadding(len(pack))]
print "ERROR: {0}".format(str(e))
return False
fileSize = os.path.getsize(FileName)
try:
[part_1, ext] = os.path.basename(FileName).split('.')
except Exception, e:
print "Provide some extension to the file"
sys.exit(1)
eventCount= 0
fileCount = 1
while True:
# Read first 4 bytes of diameter event(which is part of 20 byte header)
[msgLen, _version] = utils.getFlagAndLength(fd.read(4))
# move back by 4 bytes
fd.seek(-4, 1)
data = fd.read(msgLen)
eventCount += 1
curSize = fd.tell()
if fileSize == curSize:
break
fd.close()
return eventCount
if __name__ == "__main__":
if len(sys.argv) < 2:
