1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
|
from struct import pack, unpack
from ptrace.cpu_info import CPU_64BITS
from ctypes import cast, POINTER
def int2uint64(value):
"""
Convert a signed 64 bits integer into an unsigned 64 bits integer.
"""
if value < 0:
return 0x10000000000000000 + value
else:
return value
def uint2int64(value):
"""
Convert an unsigned 64 bits integer into a signed 64 bits integer.
"""
if value & 0x8000000000000000:
return value - 0x10000000000000000
else:
return value
def truncateWord32(value):
"""
Truncate an unsigned integer to 32 bits.
"""
return value & 0xFFFFFFFF
def truncateWord64(value):
"""
Truncate an unsigned integer to 64 bits.
"""
return value & 0xFFFFFFFFFFFFFFFF
def formatUintHex16(value):
"""
Format an 16 bits unsigned integer.
"""
return u"0x%04x" % value
def formatUintHex32(value):
"""
Format an 32 bits unsigned integer.
"""
return u"0x%08x" % value
def formatUintHex64(value):
"""
Format an 64 bits unsigned integer.
"""
return u"0x%016x" % value
def int2uint32(value):
"""
Convert a signed 32 bits integer into an unsigned 32 bits integer.
"""
if value < 0:
return 0x100000000 + value
else:
return value
def uint2int32(value):
"""
Convert an unsigned 32 bits integer into a signed 32 bits integer.
"""
if value & 0x80000000:
return value - 0x100000000
else:
return value
uint2int = uint2int32
int2uint = int2uint32
if CPU_64BITS:
ulong2long = uint2int64
long2ulong = int2uint64
formatWordHex = formatUintHex64
truncateWord = truncateWord64
else:
ulong2long = uint2int32
long2ulong = int2uint32
formatWordHex = formatUintHex32
truncateWord = truncateWord32
def formatAddress(address):
"""
Format an address to hexadecimal.
Return "NULL" for zero.
"""
if address:
return formatWordHex(address)
else:
return u"NULL"
def formatAddressRange(start, end):
"""
Format an address range, eg. "0x80004000-0x8000ffff".
"""
return u"%s-%s" % (formatWordHex(start), formatWordHex(end))
def ntoh_ushort(value):
"""
Convert an unsigned short integer from network endiant to host endian.
"""
return unpack("<H", pack(">H", value))[0]
def ntoh_uint(value):
"""
Convert an unsigned integer from network endiant to host endian.
"""
return unpack("<I", pack(">I", value))[0]
def word2bytes(word):
"""
Convert an unsigned integer (a CPU word) to a bytes string.
"""
return pack("L", word)
def bytes2word(bytes):
"""
Convert a bytes string to an unsigned integer (a CPU word).
"""
return unpack("L", bytes)[0]
def bytes2type(bytes, type):
"""
Cast a bytes string to an objet of the specified type.
"""
return cast(bytes, POINTER(type))[0]
def bytes2array(bytes, basetype, size):
"""
Cast a bytes string to an array of objets of the specified type
and size.
"""
return bytes2type(bytes, basetype * size)
|
