Demo/rpc/xdr.py

   1 # Implement (a subset of) Sun XDR -- RFC1014.
   2
   3
   4 try:
   5     import struct
   6 except ImportError:
   7     struct = None
   8
   9
  10 Long = type(0L)
  11
  12
  13 class Packer:
  14
  15     def __init__(self):
  16         self.reset()
  17
  18     def reset(self):
  19         self.buf = ''
  20
  21     def get_buf(self):
  22         return self.buf
  23
  24     def pack_uint(self, x):
  25         self.buf = self.buf + \
  26                 (chr(int(x>>24 & 0xff)) + chr(int(x>>16 & 0xff)) + \
  27                  chr(int(x>>8 & 0xff)) + chr(int(x & 0xff)))
  28     if struct and struct.pack('l', 1) == '\0\0\0\1':
  29         def pack_uint(self, x):
  30             if type(x) == Long:
  31                 x = int((x + 0x80000000L) % 0x100000000L \
  32                            - 0x80000000L)
  33             self.buf = self.buf + struct.pack('l', x)
  34
  35     pack_int = pack_uint
  36
  37     pack_enum = pack_int
  38
  39     def pack_bool(self, x):
  40         if x: self.buf = self.buf + '\0\0\0\1'
  41         else: self.buf = self.buf + '\0\0\0\0'
  42
  43     def pack_uhyper(self, x):
  44         self.pack_uint(int(x>>32 & 0xffffffff))
  45         self.pack_uint(int(x & 0xffffffff))
  46
  47     pack_hyper = pack_uhyper
  48
  49     def pack_float(self, x):
  50         # XXX
  51         self.buf = self.buf + struct.pack('f', x)
  52
  53     def pack_double(self, x):
  54         # XXX
  55         self.buf = self.buf + struct.pack('d', x)
  56
  57     def pack_fstring(self, n, s):
  58         if n < 0:
  59             raise ValueError, 'fstring size must be nonnegative'
  60         n = ((n + 3)//4)*4
  61         data = s[:n]
  62         data = data + (n - len(data)) * '\0'
  63         self.buf = self.buf + data
  64
  65     pack_fopaque = pack_fstring
  66
  67     def pack_string(self, s):
  68         n = len(s)
  69         self.pack_uint(n)
  70         self.pack_fstring(n, s)
  71
  72     pack_opaque = pack_string
  73
  74     def pack_list(self, list, pack_item):
  75         for item in list:
  76             self.pack_uint(1)
  77             pack_item(item)
  78         self.pack_uint(0)
  79
  80     def pack_farray(self, n, list, pack_item):
  81         if len(list) <> n:
  82             raise ValueError, 'wrong array size'
  83         for item in list:
  84             pack_item(item)
  85
  86     def pack_array(self, list, pack_item):
  87         n = len(list)
  88         self.pack_uint(n)
  89         self.pack_farray(n, list, pack_item)
  90
  91
  92 class Unpacker:
  93
  94     def __init__(self, data):
  95         self.reset(data)
  96
  97     def reset(self, data):
  98         self.buf = data
  99         self.pos = 0
 100
 101     def done(self):
 102         if self.pos < len(self.buf):
 103             raise RuntimeError, 'unextracted data remains'
 104
 105     def unpack_uint(self):
 106         i = self.pos
 107         self.pos = j = i+4
 108         data = self.buf[i:j]
 109         if len(data) < 4:
 110             raise EOFError
 111         x = long(ord(data[0]))<<24 | ord(data[1])<<16 | \
 112                 ord(data[2])<<8 | ord(data[3])
 113         # Return a Python long only if the value is not representable
 114         # as a nonnegative Python int
 115         if x < 0x80000000L: x = int(x)
 116         return x
 117     if struct and struct.unpack('l', '\0\0\0\1') == 1:
 118         def unpack_uint(self):
 119             i = self.pos
 120             self.pos = j = i+4
 121             data = self.buf[i:j]
 122             if len(data) < 4:
 123                 raise EOFError
 124             return struct.unpack('l', data)
 125
 126     def unpack_int(self):
 127         x = self.unpack_uint()
 128         if x >= 0x80000000L: x = x - 0x100000000L
 129         return int(x)
 130
 131     unpack_enum = unpack_int
 132
 133     unpack_bool = unpack_int
 134
 135     def unpack_uhyper(self):
 136         hi = self.unpack_uint()
 137         lo = self.unpack_uint()
 138         return long(hi)<<32 | lo
 139
 140     def unpack_hyper(self):
 141         x = self.unpack_uhyper()
 142         if x >= 0x8000000000000000L: x = x - 0x10000000000000000L
 143         return x
 144
 145     def unpack_float(self):
 146         # XXX
 147         i = self.pos
 148         self.pos = j = i+4
 149         data = self.buf[i:j]
 150         if len(data) < 4:
 151             raise EOFError
 152         return struct.unpack('f', data)[0]
 153
 154     def unpack_double(self):
 155         # XXX
 156         i = self.pos
 157         self.pos = j = i+8
 158         data = self.buf[i:j]
 159         if len(data) < 8:
 160             raise EOFError
 161         return struct.unpack('d', data)[0]
 162
 163     def unpack_fstring(self, n):
 164         if n < 0:
 165             raise ValueError, 'fstring size must be nonnegative'
 166         i = self.pos
 167         j = i + (n+3)//4*4
 168         if j > len(self.buf):
 169             raise EOFError
 170         self.pos = j
 171         return self.buf[i:i+n]
 172
 173     unpack_fopaque = unpack_fstring
 174
 175     def unpack_string(self):
 176         n = self.unpack_uint()
 177         return self.unpack_fstring(n)
 178
 179     unpack_opaque = unpack_string
 180
 181     def unpack_list(self, unpack_item):
 182         list = []
 183         while 1:
 184             x = self.unpack_uint()
 185             if x == 0: break
 186             if x <> 1:
 187                 raise RuntimeError, '0 or 1 expected, got %r' % (x, )
 188             item = unpack_item()
 189             list.append(item)
 190         return list
 191
 192     def unpack_farray(self, n, unpack_item):
 193         list = []
 194         for i in range(n):
 195             list.append(unpack_item())
 196         return list
 197
 198     def unpack_array(self, unpack_item):
 199         n = self.unpack_uint()
 200         return self.unpack_farray(n, unpack_item)