"""Implements (a subset of) Sun XDR -- eXternal Data Representation. See: RFC 1014 """ import struct # exceptions class Error: """Exception class for this module. Use: except xdrlib.Error, var: # var has the Error instance for the exception Public ivars: msg -- contains the message """ def __init__(self, msg): self.msg = msg def __repr__(self): return repr(self.msg) def __str__(self): return str(self.msg) class ConversionError(Error): pass class Packer: """Pack various data representations into a buffer.""" def __init__(self): self.reset() def reset(self): self.__buf = '' def get_buffer(self): return self.__buf # backwards compatibility get_buf = get_buffer def pack_uint(self, x): self.__buf = self.__buf + struct.pack('>L', x) pack_int = pack_uint pack_enum = pack_int def pack_bool(self, x): if x: self.__buf = self.__buf + '\0\0\0\1' else: self.__buf = self.__buf + '\0\0\0\0' def pack_uhyper(self, x): self.pack_uint(x>>32 & 0xffffffffL) self.pack_uint(x & 0xffffffffL) pack_hyper = pack_uhyper def pack_float(self, x): try: self.__buf = self.__buf + struct.pack('>f', x) except struct.error, msg: raise ConversionError, msg def pack_double(self, x): try: self.__buf = self.__buf + struct.pack('>d', x) except struct.error, msg: raise ConversionError, msg def pack_fstring(self, n, s): if n < 0: raise ValueError, 'fstring size must be nonnegative' n = ((n+3)/4)*4 data = s[:n] data = data + (n - len(data)) * '\0' self.__buf = self.__buf + data pack_fopaque = pack_fstring def pack_string(self, s): n = len(s) self.pack_uint(n) self.pack_fstring(n, s) pack_opaque = pack_string pack_bytes = pack_string def pack_list(self, list, pack_item): for item in list: self.pack_uint(1) pack_item(item) self.pack_uint(0) def pack_farray(self, n, list, pack_item): if len(list) <> n: raise ValueError, 'wrong array size' for item in list: pack_item(item) def pack_array(self, list, pack_item): n = len(list) self.pack_uint(n) self.pack_farray(n, list, pack_item) class Unpacker: """Unpacks various data representations from the given buffer.""" def __init__(self, data): self.reset(data) def reset(self, data): self.__buf = data self.__pos = 0 def get_position(self): return self.__pos def set_position(self, position): self.__pos = position def get_buffer(self): return self.__buf def done(self): if self.__pos < len(self.__buf): raise Error('unextracted data remains') def unpack_uint(self): i = self.__pos self.__pos = j = i+4 data = self.__buf[i:j] if len(data) < 4: raise EOFError x = struct.unpack('>L', data)[0] try: return int(x) except OverflowError: return x def unpack_int(self): i = self.__pos self.__pos = j = i+4 data = self.__buf[i:j] if len(data) < 4: raise EOFError return struct.unpack('>l', data)[0] unpack_enum = unpack_int unpack_bool = unpack_int def unpack_uhyper(self): hi = self.unpack_uint() lo = self.unpack_uint() return long(hi)<<32 | lo def unpack_hyper(self): x = self.unpack_uhyper() if x >= 0x8000000000000000L: x = x - 0x10000000000000000L return x def unpack_float(self): i = self.__pos self.__pos = j = i+4 data = self.__buf[i:j] if len(data) < 4: raise EOFError return struct.unpack('>f', data)[0] def unpack_double(self): i = self.__pos self.__pos = j = i+8 data = self.__buf[i:j] if len(data) < 8: raise EOFError return struct.unpack('>d', data)[0] def unpack_fstring(self, n): if n < 0: raise ValueError, 'fstring size must be nonnegative' i = self.__pos j = i + (n+3)/4*4 if j > len(self.__buf): raise EOFError self.__pos = j return self.__buf[i:i+n] unpack_fopaque = unpack_fstring def unpack_string(self): n = self.unpack_uint() return self.unpack_fstring(n) unpack_opaque = unpack_string unpack_bytes = unpack_string def unpack_list(self, unpack_item): list = [] while 1: x = self.unpack_uint() if x == 0: break if x <> 1: raise ConversionError, '0 or 1 expected, got ' + `x` item = unpack_item() list.append(item) return list def unpack_farray(self, n, unpack_item): list = [] for i in range(n): list.append(unpack_item()) return list def unpack_array(self, unpack_item): n = self.unpack_uint() return self.unpack_farray(n, unpack_item) # test suite def _test(): p = Packer() packtest = [ (p.pack_uint, (9,)), (p.pack_bool, (None,)), (p.pack_bool, ('hello',)), (p.pack_uhyper, (45L,)), (p.pack_float, (1.9,)), (p.pack_double, (1.9,)), (p.pack_string, ('hello world',)), (p.pack_list, (range(5), p.pack_uint)), (p.pack_array, (['what', 'is', 'hapnin', 'doctor'], p.pack_string)), ] succeedlist = [1] * len(packtest) count = 0 for method, args in packtest: print 'pack test', count, try: apply(method, args) print 'succeeded' except ConversionError, var: print 'ConversionError:', var.msg succeedlist[count] = 0 count = count + 1 data = p.get_buffer() # now verify up = Unpacker(data) unpacktest = [ (up.unpack_uint, (), lambda x: x == 9), (up.unpack_bool, (), lambda x: not x), (up.unpack_bool, (), lambda x: x), (up.unpack_uhyper, (), lambda x: x == 45L), (up.unpack_float, (), lambda x: 1.89 < x < 1.91), (up.unpack_double, (), lambda x: 1.89 < x < 1.91), (up.unpack_string, (), lambda x: x == 'hello world'), (up.unpack_list, (up.unpack_uint,), lambda x: x == range(5)), (up.unpack_array, (up.unpack_string,), lambda x: x == ['what', 'is', 'hapnin', 'doctor']), ] count = 0 for method, args, pred in unpacktest: print 'unpack test', count, try: if succeedlist[count]: x = apply(method, args) print pred(x) and 'succeeded' or 'failed', ':', x else: print 'skipping' except ConversionError, var: print 'ConversionError:', var.msg count = count + 1 if __name__ == '__main__': _test()