Lib/xdrlib.py

   1 """Implements (a subset of) Sun XDR -- eXternal Data Representation.
   2
   3 See: RFC 1014
   4
   5 """
   6
   7 import struct
   8 try:
   9     from cStringIO import StringIO as _StringIO
  10 except ImportError:
  11     from StringIO import StringIO as _StringIO
  12
  13 __all__ = ["Error", "Packer", "Unpacker", "ConversionError"]
  14
  15 # exceptions
  16 class Error(Exception):
  17     """Exception class for this module. Use:
  18
  19     except xdrlib.Error, var:
  20         # var has the Error instance for the exception
  21
  22     Public ivars:
  23         msg -- contains the message
  24
  25     """
  26     def __init__(self, msg):
  27         self.msg = msg
  28     def __repr__(self):
  29         return repr(self.msg)
  30     def __str__(self):
  31         return str(self.msg)
  32
  33
  34 class ConversionError(Error):
  35     pass
  36
  37
  38
  39 class Packer:
  40     """Pack various data representations into a buffer."""
  41
  42     def __init__(self):
  43         self.reset()
  44
  45     def reset(self):
  46         self.__buf = _StringIO()
  47
  48     def get_buffer(self):
  49         return self.__buf.getvalue()
  50     # backwards compatibility
  51     get_buf = get_buffer
  52
  53     def pack_uint(self, x):
  54         self.__buf.write(struct.pack('>L', x))
  55
  56     pack_int = pack_uint
  57     pack_enum = pack_int
  58
  59     def pack_bool(self, x):
  60         if x: self.__buf.write('\0\0\0\1')
  61         else: self.__buf.write('\0\0\0\0')
  62
  63     def pack_uhyper(self, x):
  64         self.pack_uint(x>>32 & 0xffffffffL)
  65         self.pack_uint(x & 0xffffffffL)
  66
  67     pack_hyper = pack_uhyper
  68
  69     def pack_float(self, x):
  70         try: self.__buf.write(struct.pack('>f', x))
  71         except struct.error, msg:
  72             raise ConversionError, msg
  73
  74     def pack_double(self, x):
  75         try: self.__buf.write(struct.pack('>d', x))
  76         except struct.error, msg:
  77             raise ConversionError, msg
  78
  79     def pack_fstring(self, n, s):
  80         if n < 0:
  81             raise ValueError, 'fstring size must be nonnegative'
  82         data = s[:n]
  83         n = ((n+3)//4)*4
  84         data = data + (n - len(data)) * '\0'
  85         self.__buf.write(data)
  86
  87     pack_fopaque = pack_fstring
  88
  89     def pack_string(self, s):
  90         n = len(s)
  91         self.pack_uint(n)
  92         self.pack_fstring(n, s)
  93
  94     pack_opaque = pack_string
  95     pack_bytes = pack_string
  96
  97     def pack_list(self, list, pack_item):
  98         for item in list:
  99             self.pack_uint(1)
 100             pack_item(item)
 101         self.pack_uint(0)
 102
 103     def pack_farray(self, n, list, pack_item):
 104         if len(list) != n:
 105             raise ValueError, 'wrong array size'
 106         for item in list:
 107             pack_item(item)
 108
 109     def pack_array(self, list, pack_item):
 110         n = len(list)
 111         self.pack_uint(n)
 112         self.pack_farray(n, list, pack_item)
 113
 114
 115
 116 class Unpacker:
 117     """Unpacks various data representations from the given buffer."""
 118
 119     def __init__(self, data):
 120         self.reset(data)
 121
 122     def reset(self, data):
 123         self.__buf = data
 124         self.__pos = 0
 125
 126     def get_position(self):
 127         return self.__pos
 128
 129     def set_position(self, position):
 130         self.__pos = position
 131
 132     def get_buffer(self):
 133         return self.__buf
 134
 135     def done(self):
 136         if self.__pos < len(self.__buf):
 137             raise Error('unextracted data remains')
 138
 139     def unpack_uint(self):
 140         i = self.__pos
 141         self.__pos = j = i+4
 142         data = self.__buf[i:j]
 143         if len(data) < 4:
 144             raise EOFError
 145         x = struct.unpack('>L', data)[0]
 146         try:
 147             return int(x)
 148         except OverflowError:
 149             return x
 150
 151     def unpack_int(self):
 152         i = self.__pos
 153         self.__pos = j = i+4
 154         data = self.__buf[i:j]
 155         if len(data) < 4:
 156             raise EOFError
 157         return struct.unpack('>l', data)[0]
 158
 159     unpack_enum = unpack_int
 160
 161     def unpack_bool(self):
 162         return bool(self.unpack_int())
 163
 164     def unpack_uhyper(self):
 165         hi = self.unpack_uint()
 166         lo = self.unpack_uint()
 167         return long(hi)<<32 | lo
 168
 169     def unpack_hyper(self):
 170         x = self.unpack_uhyper()
 171         if x >= 0x8000000000000000L:
 172             x = x - 0x10000000000000000L
 173         return x
 174
 175     def unpack_float(self):
 176         i = self.__pos
 177         self.__pos = j = i+4
 178         data = self.__buf[i:j]
 179         if len(data) < 4:
 180             raise EOFError
 181         return struct.unpack('>f', data)[0]
 182
 183     def unpack_double(self):
 184         i = self.__pos
 185         self.__pos = j = i+8
 186         data = self.__buf[i:j]
 187         if len(data) < 8:
 188             raise EOFError
 189         return struct.unpack('>d', data)[0]
 190
 191     def unpack_fstring(self, n):
 192         if n < 0:
 193             raise ValueError, 'fstring size must be nonnegative'
 194         i = self.__pos
 195         j = i + (n+3)//4*4
 196         if j > len(self.__buf):
 197             raise EOFError
 198         self.__pos = j
 199         return self.__buf[i:i+n]
 200
 201     unpack_fopaque = unpack_fstring
 202
 203     def unpack_string(self):
 204         n = self.unpack_uint()
 205         return self.unpack_fstring(n)
 206
 207     unpack_opaque = unpack_string
 208     unpack_bytes = unpack_string
 209
 210     def unpack_list(self, unpack_item):
 211         list = []
 212         while 1:
 213             x = self.unpack_uint()
 214             if x == 0: break
 215             if x != 1:
 216                 raise ConversionError, '0 or 1 expected, got %r' % (x,)
 217             item = unpack_item()
 218             list.append(item)
 219         return list
 220
 221     def unpack_farray(self, n, unpack_item):
 222         list = []
 223         for i in range(n):
 224             list.append(unpack_item())
 225         return list
 226
 227     def unpack_array(self, unpack_item):
 228         n = self.unpack_uint()
 229         return self.unpack_farray(n, unpack_item)