def getAVPs(self):
"""Returns a copy of the embedded AVPs in a list"""
avps = []
u = Unpacker(self.payload)
bytes_left = len(self.payload)
while bytes_left != 0:
sz = AVP.decodeSize(u, bytes_left)
if sz == 0:
raise InvalidAVPLengthError(self)
a = AVP(1, "")
a.decode(u, sz)
avps.append(a)
bytes_left -= sz
return avps
def _unittest():
a = AVP_Float32(1, 17.5)
assert a.queryValue() == 17.5
a.setValue(42.75)
assert a.queryValue() == 42.75
a = AVP_Float32.narrow(AVP(1, "\102\053\000\000"))
assert a.queryValue() == 42.75
try:
a = AVP_Float32.narrow(AVP(1, " "))
assert False
except InvalidAVPLengthError:
pass
def _unittest():
a = AVP_Unsigned64(1, 17)
assert a.queryValue() == 17
a.setValue(42)
assert a.queryValue() == 42
a = AVP_Unsigned64.narrow(AVP(1, " "))
assert a.queryValue() == 0x2020202020202020
try:
a = AVP_Unsigned64.narrow(AVP(1, " "))
assert False
except InvalidAVPLengthError:
pass
def _unittest():
a = AVP_Integer32(1, 17)
assert a.queryValue() == 17
a.setValue(42)
assert a.queryValue() == 42
a = AVP_Integer32.narrow(AVP(1, " "))
assert a.queryValue() == 0x20202020
try:
a = AVP_Integer32.narrow(AVP(1, "12345"))
assert False
except InvalidAVPLengthError:
pass
def copyProxyInfo(source,destination):
"""Copies any Proxy-Info AVPs from one message to another.
from The source message.
to The destination message.
"""
for a in source.subset(ProtocolConstants.DI_PROXY_INFO):
destination.append(AVP(a.code,a.payload,a.vendor_id))
def __str__(self):
if len(self.payload) == 2 + 4:
return self.str_prefix__() + " " + socket.inet_ntop(
socket.AF_INET, self.payload[2:])
elif len(self.payload) == 2 + 16:
return self.str_prefix__() + " " + socket.inet_ntop(
socket.AF_INET6, self.payload[2:])
else:
return AVP.__str__(self)
def decode(self,unpacker,bytes):
"""Decode a message from on-the-wire format.
The message is checked to be in valid format and the VPs to be of
the correct length etc. Invalid/reserved bits are not checked.
unpacker a xdrlib.Unpacker possibly containing a Diameter message
bytes the bytes to try to decode
Return the result for the decode operation.
"""
start = unpacker.get_position()
if bytes < 4:
return Message.decode_status_not_enough
v_ml = unpacker.unpack_uint()
version = v_ml>>24
sz = v_ml&0x00FFFFFF
if version!=1:
return Message.decode_status_garbage
if sz<20:
return Message.decode_status_garbage
if (sz%4)!=0:
return Message.decode_status_garbage
unpacker.set_position(start)
# header looks ok
if bytes<sz:
return Message.decode_status_not_enough
self.hdr.decode(unpacker)
self.avp = []
bytes_left = bytes - 20
while bytes_left>0:
if bytes_left<8:
return Message.decode_status_garbage
avp_sz = AVP.decodeSize(unpacker,bytes_left)
if avp_sz==0:
return Message.decode_status_garbage
if avp_sz > bytes_left:
return Message.decode_status_garbage
a = AVP(0,[])
a.decode(unpacker,avp_sz)
self.avp.append(a)
bytes_left -= avp_sz
return Message.decode_status_decoded
def _unittest():
when = 1139658264
a = AVP_Time(1,when)
assert a.querySecondsSince1970()==when
a.setSecondsSince1970(when+1)
assert a.querySecondsSince1970()==when+1
a = AVP_Time.narrow(AVP(1,"\307\230\114\230"))
assert a.querySecondsSince1970()==1139658264
def _unittest():
a = AVP_Grouped(1)
assert a.code == 1
assert len(a.getAVPs()) == 0
a1 = AVP_Grouped(1, [AVP(2, "u1"), AVP(2, "u2")])
assert len(a1.getAVPs()) == 2
a = AVP(
1,
"\000\000\000\002\000\000\000\012\165\061\000\000\000\000\000\002\000\000\000\012\165\062\000\000"
)
a1 = AVP_Grouped.narrow(a)
assert len(a1.getAVPs()) == 2
a = AVP(1, "\000\000\000\002\000\000\000\012\165\061\000\000\000")
try:
a1 = AVP_Grouped.narrow(a)
assert False
except InvalidAVPLengthError:
pass
def narrow(avp):
"""Convert generic AVP to AVP_Float64
Raises: InvalidAVPLengthError
"""
avps = []
u = Unpacker(avp.payload)
bytes_left = len(avp.payload)
while bytes_left != 0:
sz = AVP.decodeSize(u, bytes_left)
if sz == 0:
raise InvalidAVPLengthError(avp)
a = AVP(1, "")
a.decode(u, sz)
avps.append(a)
bytes_left -= sz
a = AVP_Grouped(avp.code, avps, avp.vendor_id)
a.flags = avp.flags
return a
def __init__(self, code, value, vendor_id=0):
AVP.__init__(self, code, struct.pack("!I", value), vendor_id)
def __init__(self, code, address, vendor_id=0):
"""Constructs an AVP_Address. The address is expected to tuple (family,address)"""
AVP.__init__(self, code, _pack_address(address), vendor_id)
def __str__(self):
return AVP.str_prefix__(self) + " " + str(
datetime.fromtimestamp(self.querySecondsSince1970()))
def __init__(self, code=0, payload="", vendor_id=0):
AVP.__init__(self, code, payload, vendor_id)
def __init__(self, code, value="", vendor_id=0):
AVP.__init__(self, code, utf8encoder(value)[0], vendor_id)
def __init__(self, code, avps=[], vendor_id=0):
AVP.__init__(self, code, _pack(avps), vendor_id)
def __str__(self):
return AVP.str_prefix__(self) + " " + self.queryValue()
