fixed errors with includes in scanapi
[monitor.git] / monitor / util / PHPUnserialize.py
1 import types, string, re
2
3 """
4 Unserialize class for the PHP serialization format.
5
6 @version v0.4 BETA
7 @author Scott Hurring; scott at hurring dot com
8 @copyright Copyright (c) 2005 Scott Hurring
9 @license http://opensource.org/licenses/gpl-license.php GNU Public License
10 $Id: PHPUnserialize.py,v 1.1 2006/01/08 21:53:19 shurring Exp $
11
12 Most recent version can be found at:
13 http://hurring.com/code/python/phpserialize/
14
15 Usage:
16 # Create an instance of the unserialize engine
17 u = PHPUnserialize()
18 # unserialize some string into python data
19 data = u.unserialize(serialized_string)
20
21 Please see README.txt for more information.
22 """
23
24 class PHPUnserialize(object):
25         """
26         Class to unserialize something from the PHP Serialize format.
27
28         Usage:
29         u = PHPUnserialize()
30         data = u.unserialize(serialized_string)
31         """
32
33         def __init__(self):
34                 pass
35
36         def session_decode(self, data):
37                 """Thanks to Ken Restivo for suggesting the addition
38                 of session_encode
39                 """
40                 session = {}
41                 while len(data) > 0:
42                         m = re.match('^(\w+)\|', data)
43                         if m:
44                                 key = m.group(1)
45                                 offset = len(key)+1
46                                 (dtype, dataoffset, value) = self._unserialize(data, offset)
47                                 offset = offset + dataoffset
48                                 data = data[offset:]
49                                 session[key] = value
50                         else:
51                                 # No more stuff to decode 
52                                 return session
53                 
54                 return session
55                 
56         def unserialize(self, data):
57                 return self._unserialize(data, 0)[2]
58
59         def _unserialize(self, data, offset=0):
60                 """
61                 Find the next token and unserialize it.
62                 Recurse on array.
63
64                 offset = raw offset from start of data
65                 
66                 return (type, offset, value)
67                 """
68
69                 buf = []
70                 dtype = string.lower(data[offset:offset+1])
71
72                 #print "# dtype =", dtype
73
74                 # 't:' = 2 chars
75                 dataoffset = offset + 2
76                 typeconvert = lambda x : x
77                 chars = datalength = 0
78
79                 # int => Integer
80                 if dtype == 'i':
81                         typeconvert = lambda x : int(x)
82                         (chars, readdata) = self.read_until(data, dataoffset, ';')
83                         # +1 for end semicolon
84                         dataoffset += chars + 1
85
86                 # bool => Boolean
87                 elif dtype == 'b':
88                         typeconvert = lambda x : (int(x) == 1)
89                         (chars, readdata) = self.read_until(data, dataoffset, ';')
90                         # +1 for end semicolon
91                         dataoffset += chars + 1
92
93                 # double => Floating Point
94                 elif dtype == 'd':
95                         typeconvert = lambda x : float(x)
96                         (chars, readdata) = self.read_until(data, dataoffset, ';')
97                         # +1 for end semicolon
98                         dataoffset += chars + 1
99
100                 # n => None
101                 elif dtype == 'n':
102                         readdata = None
103
104                 # s => String
105                 elif dtype == 's':
106                         (chars, stringlength) = self.read_until(data, dataoffset, ':')
107                         # +2 for colons around length field
108                         dataoffset += chars + 2
109
110                         # +1 for start quote
111                         (chars, readdata) = self.read_chars(data, dataoffset+1, int(stringlength))
112                         # +2 for endquote semicolon
113                         dataoffset += chars + 2
114
115                         if chars != int(stringlength) != int(readdata):
116                                 raise Exception("String length mismatch")
117
118                 # array => Dict
119                 # If you originally serialized a Tuple or List, it will
120                 # be unserialized as a Dict.  PHP doesn't have tuples or lists,
121                 # only arrays - so everything has to get converted into an array
122                 # when serializing and the original type of the array is lost
123                 elif dtype == 'a':
124                         readdata = {}
125
126                         # If all dict keys are increasing ints from zero, 
127                         #       then make it a list.
128                         # Else, 
129                         #       just return the original dict
130                         def is_list(keys):
131                                 # list with no elements
132                                 if len(keys) == 0:
133                                         return True
134                                 # list with one element: 0
135                                 if len(keys) == 1:
136                                         if type(keys[0]) == int and keys[0] == 0:
137                                                 return True
138                                         else:
139                                                 return False
140
141                                 # all other cases
142                                 for i in range(1,len(keys)):
143                                         x = keys[i-1]
144                                         y = keys[i]
145                                         if type(x) == int and type(y) == int and y-x == 1:
146                                                 continue
147                                         else:
148                                                 return False
149                                 return True
150
151                         # Empty {} and empty [] are ambiguous. 
152                         # A default could either be configured or assumed to be a list?
153                         def dict_to_list(dict):
154
155                                 keys = dict.keys()
156                                 keys.sort()
157
158                                 if is_list(keys):
159                                         return [dict[k] for k in keys]
160                                 else:
161                                         return dict
162                                 
163                         typeconvert = lambda x : dict_to_list(x)
164
165                         # How many keys does this list have?
166                         (chars, keys) = self.read_until(data, dataoffset, ':')
167                         # +2 for colons around length field
168                         dataoffset += chars + 2
169
170                         # Loop through and fetch this number of key/value pairs
171                         for i in range(0, int(keys)):
172                                 # Read the key
173                                 (ktype, kchars, key) = self._unserialize(data, dataoffset)
174                                 dataoffset += kchars
175                                 #print "Key(%i) = (%s, %i, %s) %i" % (i, ktype, kchars, key, dataoffset)
176
177                                 # Read value of the key
178                                 (vtype, vchars, value) = self._unserialize(data, dataoffset)
179                                 dataoffset += vchars
180                                 #print "Value(%i) = (%s, %i, %s) %i" % (i, vtype, vchars, value, dataoffset)
181
182                                 # Set the list element
183                                 readdata[key] = value
184
185                                 # +1 for end semicolon
186                         dataoffset += 1
187                         #chars = int(dataoffset) - start
188
189                 # I don't know how to unserialize this
190                 else:
191                         raise Exception("Unknown / Unhandled data type (%s)!" % dtype)
192
193
194                 return (dtype, dataoffset-offset, typeconvert(readdata))
195
196         def read_until(self, data, offset, stopchar):
197                 """
198                 Read from data[offset] until you encounter some char 'stopchar'.
199                 """
200                 buf = []
201                 char = data[offset:offset+1]
202                 i = 2
203                 while char != stopchar:
204                         # Consumed all the characters and havent found ';'
205                         if i+offset > len(data):
206                                 raise Exception("Invalid")
207                         buf.append(char)
208                         char = data[offset+(i-1):offset+i]
209                         i += 1
210
211                 # (chars_read, data)
212                 return (len(buf), "".join(buf))
213
214         def read_chars(self, data, offset, length):
215                 """
216                 Read 'length' number of chars from data[offset].
217                 """
218                 buf = []
219                 # Account for the starting quote char
220                 #offset += 1
221                 for i in range(0, length):
222                         char = data[offset+(i-1):offset+i]
223                         buf.append(char)
224
225                 # (chars_read, data)
226                 return (len(buf), "".join(buf))
227
228