Source Code for Module vdb.gui.extensions.windows

  1   
  2  import os 
  3  import vwidget 
  4  import vwidget.windows as vw_windows 
  5  import vwidget.util as vw_util 
  6  import vtrace.tools.win32heap as win32heap 
  7   
  8  import vdb 
  9  import vdb.gui 
 10   
 11  import envi.memcanvas as e_canvas 
 12  import vwidget.memview as vw_memview 
 13   
 14  import gtk 
 15  import pango 
 16   
 17  busy_color = (0xff, 0, 0) 
 18  def_color  = (0, 0xff, 0) 
 19   
 20 -class VdbHeapRenderer(e_canvas.MemoryRenderer): 
 21      """ 
 22      A renderer which knows how to show heap chunks 
 23      (only to be used on aligned addresses, our parent window 
 24      takes care of that) 
 25      """ 
 26 -    def __init__(self, trace): 
 27          self.trace = trace 
 28   
 29 -    def getPad(self, buf, size): 
 30          return " " * (size-len(buf)) 
 31   
 32 -    def isAscii(self, buf): 
 33          for b in buf: 
 34              v = ord(b) 
 35              if v == 0: 
 36                  continue 
 37              if v < 0x20 or v >= 0x7f: 
 38                  return False 
 39          return True 
 40   
 41 -    def render(self, canvas, va): 
 42          chunk = win32heap.Win32Chunk(self.trace, va) 
 43          size = len(chunk) 
 44          canvas.addVaText("0x%.8x" % va, va=va) 
 45          canvas.addText(": ") 
 46          sizestr = str(len(chunk)) 
 47          sizepad = self.getPad(sizestr, 7) 
 48          canvas.addText("CHUNK:%s" % sizepad) 
 49          canvas.addNameText(sizestr, name="chunk:%d" % size) 
 50          canvas.addText(" %s" % chunk.reprFlags()) 
 51          canvas.addText("\n") 
 52   
 53          dva = chunk.getDataAddress() 
 54          dsize = chunk.getDataSize() 
 55          #r = min(32, dsize) 
 56          canvas.addVaText("0x%.8x" % dva, va=dva) 
 57          dsizestr = str(dsize) 
 58          dsizepad = self.getPad(dsizestr, 7) 
 59          canvas.addText(": %s" % dsizepad) 
 60          canvas.addNameText(dsizestr, name="data:%d" % dsize) 
 61          canvas.addText(": ") 
 62   
 63          bytes = self.trace.readMemory(dva, dsize) 
 64   
 65          if not chunk.isBusy(): 
 66              flink, blink = self.trace.readMemoryFormat(dva, "PP") 
 67              canvas.addText("FLINK: ") 
 68              canvas.addVaText("0x%.8x" % flink, va=flink) 
 69              canvas.addText(" BLINK: ") 
 70              canvas.addVaText("0x%.8x" % blink, va=blink) 
 71              canvas.addText(" leftovers: %s" % bytes[8:8+32].encode('hex')) 
 72   
 73          else: 
 74              if self.isAscii(bytes): 
 75                  canvas.addText(bytes[:128].replace("\x00","")) 
 76              else: 
 77                  canvas.addText("%s" % bytes[:32].encode('hex')) 
 78   
 79          canvas.addText("\n") 
 80   
 81          return size 
 82   
 83 -class VdbHeapView(vw_memview.MemoryView): 
 84   
 85 -    def render(self, va, size, rend=None): 
 86          trace = self.mem 
 87          heap, seg, chunk = win32heap.getHeapSegChunk(trace, va) 
 88          va = seg.address 
 89   
 90          # FIXME if is valid 
 91          last = seg.getLastChunk() 
 92          size = (last.address+len(last))-va 
 93   
 94          vw_memview.MemoryView.render(self, va, size, rend=rend) 
 95   
 96   
 97 -class VdbHeapWindow(vw_memview.MemoryWindow): 
 98 -    def __init__(self, db, gui): 
 99          self.db = db 
100          self.gui = gui 
101          self.trace = vdb.VdbTrace(db) 
102   
103          canvas = VdbHeapView(self.trace, syms=self.trace) 
104          canvas.addRenderer("Windows Heap", VdbHeapRenderer(self.trace)) 
105          vw_memview.MemoryWindow.__init__(self, canvas) 
106   
107      # These are straight stolen from vdb gui 
108 -    def setTraceWindowActive(self, active=True): 
109          if active: 
110              self.vbox.set_sensitive(True) 
111              self.updateMemoryView() 
112          else: 
113              self.vbox.set_sensitive(False) 
114   
115 -    def updateMemoryView(self, *args): 
116   
117          trace = self.db.getTrace() 
118          if (not trace.isAttached()) or trace.isRunning(): 
119              return 
120   
121          return vw_memview.MemoryWindow.updateMemoryView(self, *args) 
122   
123 -class Win32HeapWindow(vw_windows.VWindow): 
124 -    def __init__(self, db): 
125          vw_windows.VWindow.__init__(self, os.path.join(vdb.basepath,"glade","Win32Heap.glade"), None) 
126          self.vdb = db 
127          self.font = pango.FontDescription("Monospace 10") 
128          self.setupHeapTree() 
129          self.setupChunkList() 
130          self.spaceview = vwidget.SpaceView([], dwidth=40) 
131          hb = self.getWidget("hbox1") 
132          hb.pack_start(self.spaceview, expand=False) 
133          self.spaceview.show() 
134          hb.resize_children() 
135   
136 -    def chunkListActivated(self, tree, path, column): 
137          model = tree.get_model() 
138          iter = model.get_iter(path) 
139          chunk = model.get_value(iter, 0) 
140          vdb.gui.MemoryWindow(self.vdb, "0x%.8x" % chunk.address, len_expr=str(len(chunk))) 
141   
142 -    def heapTreeActivated(self, tree, path, column): 
143          model = tree.get_model() 
144          iter = model.get_iter(path) 
145          o = model.get_value(iter, 0) 
146          if isinstance(o, win32heap.Win32Heap): 
147              if tree.row_expanded(path): 
148                  tree.collapse_row(path) 
149              else: 
150                  tree.expand_row(path, False) 
151          elif isinstance(o, win32heap.Win32Segment): 
152              self.updateChunkList(o) 
153   
154 -    def updateWindow(self, trace): 
155          self.updateHeapTree() 
156   
157 -    def setupChunkList(self): 
158          tree = self.getWidget("Win32ChunkList") 
159          tree.modify_font(self.font) 
160          col1 = vw_util.makeColumn("Chunkaddr", 1) 
161          col2 = vw_util.makeColumn("Size", 2) 
162          col3 = vw_util.makeColumn("Busy", 3) # FIXME make a picture? 
163          col4 = vw_util.makeColumn("Bytes", 4) 
164          tree.append_column(col1) 
165          tree.append_column(col2) 
166          tree.append_column(col3) 
167          tree.append_column(col4) 
168          store =  gtk.ListStore(object,str,str,str,str) 
169          tree.set_model(store) 
170   
171 -    def updateChunkList(self, seg): 
172          """ 
173          Because this is already parsing chunks, we'll have this update 
174          the segment view as well. 
175          """ 
176          tree = self.getWidget("Win32ChunkList") 
177          model = tree.get_model() 
178          model.clear() 
179   
180          spaces = [] 
181          for c in seg.getChunks(): 
182   
183              if c.isBusy(): 
184                  color = busy_color 
185                  bstr = "X" 
186              else: 
187                  color = def_color 
188                  bstr = "" 
189   
190              bytes = c.getDataBytes(maxsize=10) 
191              r = "" 
192              for b in bytes: 
193                  ob = ord(b) 
194                  if ob >= 0x20 and ob < 0x7f: 
195                      r += b 
196                  else: 
197                      r += "." 
198   
199              spaces.append((c.address, len(c), color, r)) 
200              model.append((c, "0x%.8x" % c.address, len(c), bstr, r)) 
201   
202          self.spaceview.updateSpaces(spaces) 
203   
204 -    def setupHeapTree(self): 
205          tree = self.getWidget("Win32HeapTree") 
206          tree.modify_font(self.font) 
207          col1 = vw_util.makeColumn("Heap", 1) 
208          col2 = vw_util.makeColumn("Segment", 2) 
209          tree.append_column(col1) 
210          tree.append_column(col2) 
211          store =  gtk.TreeStore(object,str,str) 
212          tree.set_model(store) 
213          self.updateHeapTree(tree) 
214   
215 -    def updateHeapTree(self, tree=None): 
216          if tree == None: 
217              tree = self.getWidget("Win32HeapTree") 
218          t = self.vdb.getTrace() 
219          model = tree.get_model() 
220          model.clear() 
221          if not t.isAttached(): 
222              return 
223   
224          # Populate the heap list 
225          for h in win32heap.getHeaps(t): 
226              #i = model.append(None, (h,"0x%.8x" % h.address,"0x%.8x" % int(h.heap.Flags),"")) 
227              for s in h.getSegments(): 
228                  i = model.append(None, (s, "0x%.8x" % h.address,"0x%.8x" % s.address)) 
229                  model.append(i, (None, repr(h.heap), repr(s.seg))) 
230   
231 -def heapview(db, line): 
232      """ 
233      Open a Win32 Heap View window. 
234   
235      Usage: heapview 
236      """ 
237      Win32HeapWindow(db) 
238   
239 -def vdbGuiExtension(db, gui): 
240      db.registerCmdExtension(heapview) 
241      gui.addExtensionWindow("Windows Heap", VdbHeapWindow) 
242