← Back to branch summary

~ubuntu-branches/ubuntu/maverick/radare/maverick

« back to all changes in this revision

Viewing changes to api/lua/radare/api.lua

  • Committer: Bazaar Package Importer
  • Author(s): SevenMachines
  • Date: 2010-09-07 15:44:27 UTC
  • mfrom: (1.1.3 upstream) (2.1.4 sid)
  • Revision ID: james.westby@ubuntu.com-20100907154427-37u92vu12tqabqqz
Tags: 1:1.5.2-3ubuntu1
https://launchpad.net/bugs/621016
https://launchpad.net/bugs/618809
* Merge from debian testing (LP: #621016)
* debian/control:
     + libvala-dev transition to libval-0.10-dev (LP: #618809) 

Show diffs side-by-side

added added

removed removed

Lines of Context:
api/lua/radare/api.lua
 
1
--
 
2
-- radare lua api
 
3
--
 
4
-- 2008 pancake <youterm.com>
 
5
 
 
6
 
 
7
        -- ========== --
 
8
        --            --
 
9
        -- Namespaces --
 
10
        --            --
 
11
        -- ========== --
 
12
 
 
13
Radare          = {}
 
14
Radare.Analyze  = {}
 
15
Radare.Print    = {}
 
16
Radare.Search   = {}
 
17
Radare.Config   = {}
 
18
Radare.Code     = {}
 
19
Radare.Hash     = {}
 
20
Radare.Debugger = {}
 
21
Radare.Write    = {}
 
22
Radare.Utils    = {}
 
23
 
 
24
        -- ================= --
 
25
        --                   --
 
26
        -- Namespace aliases --
 
27
        --                   --
 
28
        -- ================= --
 
29
 
 
30
r    = Radare
 
31
a    = Radare.Analyze
 
32
p    = Radare.Print
 
33
cfg  = Radare.Config
 
34
code = Radare.Code
 
35
hash = Radare.Hash
 
36
s    = Radare.Search
 
37
d    = Radare.Debugger
 
38
w    = Radare.Write
 
39
u    = Radare.Utils
 
40
 
 
41
 
 
42
        -- ================ --
 
43
        --                  --
 
44
        -- Helper functions --
 
45
        --                  --
 
46
        -- ================ --
 
47
 
 
48
function help(table)
 
49
        if table == nil then
 
50
                print "Use help(Radare), help(Radare.Debugger) or help(Radare.Print)"
 
51
                print "These namespaces has been aliased as 'r', 'd' and 'p'."
 
52
        else
 
53
                for key,val in pairs(table) do print("  "..key) end
 
54
        end
 
55
        return 0
 
56
end
 
57
 
 
58
function list(table)
 
59
        local i
 
60
        i = 0
 
61
        if table == nil then
 
62
                print "List the contents of a table"
 
63
        else
 
64
                --for key,val in pairs(table) do print("  "..key) end
 
65
                for k,v in pairs(table) do
 
66
                        if v == nil then
 
67
                                print("  "..k) -- XXX crash
 
68
                        else
 
69
                                print("  "..k..": "..v)
 
70
-- k('?')
 
71
                        end
 
72
                        i = i + 1
 
73
                end
 
74
        end
 
75
        return n
 
76
end
 
77
 
 
78
-- join strings from a table
 
79
function join(delimiter, list)
 
80
  local len = getn(list)
 
81
  if len == 0 then 
 
82
    return "" 
 
83
  end
 
84
  local string = list[1]
 
85
  for i = 2, len do 
 
86
    string = string .. delimiter .. list[i] 
 
87
  end
 
88
  return string
 
89
end
 
90
 
 
91
-- split a string by a separator
 
92
function split(text, sep)
 
93
        sep = sep or "\n"
 
94
        text = chomp(text)
 
95
        local lines = {}
 
96
        local pos = 1
 
97
        while true do
 
98
                local b,e = text:find(sep, pos)
 
99
                if not b then table.insert(lines, text:sub(pos)) break end
 
100
                table.insert(lines, text:sub(pos,b-1))
 
101
                pos = e + 1
 
102
        end
 
103
        return lines
 
104
end
 
105
 
 
106
function chomp(text)
 
107
        if text == nil then return "" end
 
108
        return string.gsub(text, "\n$", "")
 
109
end
 
110
 
 
111
function chop(text)
 
112
        if text == nil then return "" end
 
113
        text = string.gsub(text, "\ *$", "")
 
114
        return string.gsub(text, "^\ *", "")
 
115
end
 
116
 
 
117
function hexpairs(buf)
 
118
      for byte=1, #buf, 16 do
 
119
         local chunk = buf:sub(byte, byte+15)
 
120
         io.write(string.format('%08X  ',byte-1))
 
121
         chunk:gsub('.', function (c) io.write(string.format('%02X ',string.byte(c))) end)
 
122
         io.write(string.rep(' ',3*(16-#chunk)))
 
123
         io.write(' ',chunk:gsub('%c','.'),"\n") 
 
124
      end
 
125
end
 
126
 
 
127
function hexdump(buf)
 
128
   for i=1,math.ceil(#buf/16) * 16 do
 
129
      if (i-1) % 16 == 0 then io.write(string.format('%08X  ', i-1)) end
 
130
      io.write( i > #buf and '   ' or string.format('%02X ', buf:byte(i)) )
 
131
      if i %  8 == 0 then io.write(' ') end
 
132
      if i % 16 == 0 then io.write( buf:sub(i-16+1, i):gsub('%c','.'), '\n' ) end
 
133
   end
 
134
end
 
135
 
 
136
 
 
137
 
 
138
 
 
139
 
 
140
 
 
141
 
 
142
 
 
143
 
 
144
        -- ==================== --
 
145
        --                      --
 
146
        -- Radare API functions --
 
147
        --                      --
 
148
        -- ==================== --
 
149
 
 
150
function Radare.get(value)
 
151
        -- | cut -d ' ' -f 1");
 
152
        foo = split(
 
153
                string.gsub(
 
154
                  cmd_str("? "..value),'(0x[^ ])', 
 
155
                        function(x)return x end),';')
 
156
        return tonumber(foo[1])
 
157
end
 
158
 
 
159
Radare.bytes_help = 'Radare.bytes(addr)\tReturn hexpair string with block_size bytes at [addr]'
 
160
function Radare.bytes(addr)
 
161
        local res = split(Radare.cmd("pX @"..addr), " ")
 
162
        -- TODO
 
163
        return res;
 
164
end
 
165
 
 
166
Radare.cmd_help = 'Radare.cmd(command)\tExecutes a radare command and returns its output'
 
167
function Radare.cmd(cmd)
 
168
        return chomp(cmd_str(cmd))
 
169
end
 
170
 
 
171
Radare.system_help = 'Radare.system(command)\tExecute an IO system command'
 
172
function Radare.system(command)
 
173
        r.cmd("!!"..command)
 
174
        -- todo handle errors here
 
175
        return 0
 
176
end
 
177
 
 
178
Radare.iosystem_help = 'Radare.iosystem(command)\tExecute an IO system command'
 
179
function Radare.iosystem(command)
 
180
        r.cmd("!"..command)
 
181
        -- todo handle errors here
 
182
        return 0
 
183
end
 
184
 
 
185
function Radare.open(filename)
 
186
        r.cmd("o "..filename)
 
187
        -- todo handle errors here
 
188
        return 0
 
189
end
 
190
 
 
191
function Radare.attach(pid)
 
192
        return r.cmd("o pid://"..pid)
 
193
end
 
194
 
 
195
function Radare.debug(filename)
 
196
        return r.cmd("o dbg://"..filename)
 
197
end
 
198
 
 
199
function Radare.seek(offset)
 
200
        r.cmd("s "..offset)
 
201
        return 0
 
202
end
 
203
 
 
204
function Radare.undo_seek()
 
205
        r.cmd("u")
 
206
        -- todo handle errors here
 
207
        return 0
 
208
end
 
209
 
 
210
function Radare.redo_seek()
 
211
        r.cmd("uu")
 
212
        -- todo handle errors here
 
213
        return 0
 
214
end
 
215
 
 
216
function Radare.resize(newsize)
 
217
        r.cmd("r "..newsize)
 
218
        -- todo handle errors here
 
219
        return 0
 
220
end
 
221
 
 
222
function Radare.fortune()
 
223
        return r.cmd("fortune")
 
224
end
 
225
 
 
226
function Radare.interpret(file)
 
227
        -- control block size
 
228
        r.cmd(". "..file)
 
229
        return 0
 
230
end
 
231
 
 
232
function Radare.copy(size,address)
 
233
        -- control block size
 
234
        if address == nil then
 
235
                r.cmd("y "..size)
 
236
        else
 
237
                r.cmd("y "..size.." @ "..address)
 
238
        end
 
239
        return 0
 
240
end
 
241
 
 
242
function Radare.paste(address)
 
243
        -- control block size
 
244
        if address == nil then
 
245
                r.cmd("yy ")
 
246
        else
 
247
                r.cmd("yy @ "..address)
 
248
        end
 
249
        r.cmd("y "..offset)
 
250
        return 0
 
251
end
 
252
 
 
253
function Radare.endian(big)
 
254
        r.cmd("eval cfg.bigendian = "..big)
 
255
        return 0
 
256
end
 
257
 
 
258
function Radare.flag(name, address) -- rename to r.set() ?
 
259
        if address == nil then
 
260
                r.cmd("f "..name)
 
261
        else
 
262
                r.cmd("f "..name.." @ "..address)
 
263
        end
 
264
        return 0
 
265
end
 
266
 
 
267
function Radare.flag_get(name) -- rename to r.get() ?
 
268
        local foo = str.split(r.cmd("? "..name), " ")
 
269
        return foo[1]
 
270
end
 
271
 
 
272
function Radare.flag_remove(name) -- rename to r.remove() ?
 
273
        r.cmd("f -"..name)
 
274
        return 0
 
275
end
 
276
 
 
277
function Radare.flag_rename(oldname, newname)
 
278
        r.cmd("fr "..oldname.." "..newname)
 
279
        return 0
 
280
end
 
281
 
 
282
function Radare.flag_list(filter)
 
283
        local list = split(r.cmd("f"))
 
284
        local ret = {}
 
285
        local i = 1
 
286
        while list[i] ~= nil do
 
287
                local foo = split(list[i], " ")
 
288
                ret[i] = foo[4]
 
289
                i = i + 1
 
290
        end
 
291
        return ret
 
292
end
 
293
 
 
294
function Radare.eval(key, value)
 
295
        if value == nil then
 
296
                return r.cmd("eval "..key)
 
297
        end
 
298
        return r.cmd("eval "..key.." = "..value)
 
299
end
 
300
 
 
301
function Radare.cmp(value, address)
 
302
        if address == nil then
 
303
                r.cmd("c "..value)
 
304
        else
 
305
                r.cmd("c "..value.." @ "..address)
 
306
        end
 
307
        -- parse output and get ret value
 
308
        return 0
 
309
end
 
310
 
 
311
function Radare.cmp_file(file, address)
 
312
        if address == nil then
 
313
                r.cmd("cf "..file)
 
314
        else
 
315
                r.cmd("cf "..file.." @ "..address)
 
316
        end
 
317
        -- parse output and get ret value
 
318
        return 0
 
319
end
 
320
 
 
321
function Radare.quit()
 
322
        r.cmd("q");
 
323
        return 0
 
324
end
 
325
 
 
326
function Radare.exit()
 
327
        return r.quit()
 
328
end
 
329
 
 
330
-- Radare.Analyze
 
331
 
 
332
function Radare.Analyze.opcode(addr)
 
333
        if addr == nil then addr = "" else addr= "@ "..addr end
 
334
        local res = split(Radare.cmd("ao "..addr),"\n")
 
335
        local ret = {}
 
336
        for i = 1, #res do
 
337
                local line = split(res[i], "=")
 
338
                ret[chop(line[1])] = chop(line[2])
 
339
        end
 
340
        return ret;
 
341
end
 
342
 
 
343
function Radare.Analyze.block(addr)
 
344
        if addr == nil then addr = "" else addr= "@ "..addr end
 
345
        local res = split(Radare.cmd("ab "..addr),"\n")
 
346
        local ret = {}
 
347
        for i = 1, #res do
 
348
                local line = split(res[i], "=")
 
349
                ret[chop(line[1])] = chop(line[2])
 
350
        end
 
351
        return ret;
 
352
end
 
353
-- Radare.Debugger API
 
354
 
 
355
function Radare.Debugger.step(times)
 
356
        r.cmd("!step "..times);
 
357
        return Radare.Debugger
 
358
end
 
359
 
 
360
function Radare.Debugger.attach(pid)
 
361
        r.cmd("!attach "..pid);
 
362
        return Radare.Debugger
 
363
end
 
364
 
 
365
function Radare.Debugger.detach(pid)
 
366
        r.cmd("!detach")
 
367
        return Radare.Debugger
 
368
end
 
369
 
 
370
function Radare.Debugger.jmp(address)
 
371
        r.cmd("!jmp "..address)
 
372
        return Radare.Debugger
 
373
end
 
374
 
 
375
function Radare.Debugger.set(register, value)
 
376
        r.cmd("!set "..register.." "..value)
 
377
        return Radare.Debugger
 
378
end
 
379
 
 
380
function Radare.Debugger.call(address)
 
381
        r.cmd("!call "..address)
 
382
        return Radare.Debugger
 
383
end
 
384
 
 
385
function Radare.Debugger.dump(name)
 
386
        r.cmd("!dump "..name)
 
387
        return Radare.Debugger
 
388
end
 
389
 
 
390
function Radare.Debugger.restore(name)
 
391
        r.cmd("!restore "..name)
 
392
        return Radare.Debugger
 
393
end
 
394
 
 
395
function Radare.Debugger.bp(address)
 
396
        r.cmd("!bp "..address)
 
397
        return Radare.Debugger
 
398
end
 
399
 
 
400
-- print stuff
 
401
 
 
402
function Radare.Print.hex(size, address)
 
403
        if size == nil then size = "" end
 
404
        if address == nil then
 
405
                return r.cmd(":pX "..size)
 
406
        else
 
407
                return r.cmd(":pX "..size.." @ "..address)
 
408
        end
 
409
end
 
410
 
 
411
function Radare.Print.dis(nops, address)
 
412
        if nops == nil then nops = "" end
 
413
        if address == nil then
 
414
                return r.cmd("pd "..nops)
 
415
        else
 
416
                return r.cmd("pd "..nops.." @ "..address)
 
417
        end
 
418
end
 
419
 
 
420
function Radare.Print.disasm(size, address)
 
421
        if size == nil then size = "" end
 
422
        if address == nil then
 
423
                return r.cmd("pD "..size)
 
424
        else
 
425
                return r.cmd("pD "..size.." @ "..address)
 
426
        end
 
427
end
 
428
 
 
429
function Radare.Print.bin(size, address) -- size has no sense here
 
430
        if size == nil then size = "" end
 
431
        if address == nil then
 
432
                return r.cmd(":pb "..size)
 
433
        else
 
434
                return r.cmd(":pb "..size.." @ "..address)
 
435
        end
 
436
end
 
437
 
 
438
function Radare.Print.string(address) -- size has no sense here
 
439
        if address == nil then
 
440
                return r.cmd("pz ")
 
441
        else
 
442
                return r.cmd("pz @ "..address)
 
443
        end
 
444
end
 
445
 
 
446
function Radare.Print.oct(size,address) -- size has no sense here
 
447
        if size == nil then size = "" end
 
448
        if address == nil then
 
449
                return r.cmd(":po "..size)
 
450
        end
 
451
        return r.cmd(":po "..size.."@ "..address)
 
452
end
 
453
 
 
454
-- search stuff
 
455
 
 
456
function Radare.Search.parse(string)
 
457
        local res = split(string,"\n")
 
458
        local ret = {}
 
459
        for i = 1, #res do
 
460
                local line = split(res[i], " ")
 
461
                ret[i] = line[3]
 
462
        end
 
463
        return ret;
 
464
end
 
465
 
 
466
function Radare.Search.string(string)
 
467
        return Radare.Search.parse(Radare.cmd("/ "..string))
 
468
end
 
469
 
 
470
function Radare.Search.hex(string)
 
471
        return Radare.Search.parse(Radare.cmd("/x "..string))
 
472
end
 
473
 
 
474
function Radare.Search.replace(hex_search, hex_write, delta)
 
475
        if delta == nil then
 
476
                Radare.Config.set("cmd.hit","wx "..hex_write)
 
477
        else
 
478
                Radare.Config.set("cmd.hit","wx "..hex_write.." @ +"..delta)
 
479
        end
 
480
        return Radare.Search.parse(Radare.cmd("/x "..hex_search))
 
481
end
 
482
 
 
483
-- write stuff
 
484
 
 
485
function Radare.Write.hex(string, address)
 
486
        if address == nil then
 
487
                return r.cmd("wx "..string)
 
488
        else
 
489
                return r.cmd("wx "..string.." @ "..address)
 
490
        end
 
491
end
 
492
 
 
493
function Radare.Write.string(string, address)
 
494
        if address == nil then
 
495
                return r.cmd("w ", string)
 
496
        else
 
497
                return r.cmd("w "..string.." @ "..address)
 
498
        end
 
499
end
 
500
 
 
501
function Radare.Write.wide_string(string, address)
 
502
        if address == nil then
 
503
                return r.cmd("ws "..string)
 
504
        else
 
505
                return r.cmd("ws "..string.." @ "..address)
 
506
        end
 
507
end
 
508
 
 
509
function Radare.asm(string)
 
510
        return r.cmd("!rasm '".. string.."'")
 
511
end
 
512
 
 
513
function Radare.Write.asm(string, address)
 
514
        if address == nil then
 
515
                return r.cmd("wa ".. string)
 
516
        else
 
517
                return r.cmd("wa "..string.." @ "..address)
 
518
        end
 
519
end
 
520
 
 
521
function Radare.Write.rscasm(string, address)
 
522
        if address == nil then
 
523
                return r.cmd("wA "..string)
 
524
        else
 
525
                return r.cmd("wA "..string.." @ "..address)
 
526
        end
 
527
end
 
528
 
 
529
function Radare.Write.from_file(filename, address)
 
530
        if address == nil then
 
531
                return r.cmd("wf "..filename)
 
532
        else
 
533
                return r.cmd("wf "..filename.." @ "..address)
 
534
        end
 
535
end
 
536
 
 
537
-- config stuff
 
538
 
 
539
-- eval like
 
540
function Radare.Config.verbose(level)
 
541
        Radare.Config.set("asm.syntax","intel")
 
542
        Radare.Config.set("asm.lines","false")
 
543
        Radare.Config.set("asm.offset","false")
 
544
        Radare.Config.set("asm.bytes","false")
 
545
        Radare.Config.set("asm.flags","false")
 
546
        Radare.Config.set("asm.split","false")
 
547
        Radare.Config.set("scr.color","false")
 
548
        Radare.Config.set("asm.comments","false")
 
549
        if level >= 1 then
 
550
                Radare.Config.set("asm.size", "true")
 
551
        end
 
552
        if level >= 2 then
 
553
                Radare.Config.set("asm.offset", "true")
 
554
        end
 
555
        if level >= 3 then
 
556
                Radare.Config.set("asm.lines", "true")
 
557
                Radare.Config.set("asm.bytes", "true")
 
558
                Radare.Config.set("asm.split", "true")
 
559
                Radare.Config.set("asm.flags", "true")
 
560
                Radare.Config.set("scr.color", "true")
 
561
                Radare.Config.set("asm.comments","true")
 
562
        end
 
563
end
 
564
 
 
565
-- TODO: store/restore eval config
 
566
local Radare_Config_storage = {}
 
567
function Radare.Config.store()
 
568
        local lines = split(r.cmd("e"),"\n")
 
569
        for i = 1, #lines do
 
570
                local a = split(lines[i],"=")
 
571
                if a[1] ~= nil then
 
572
                        if a[2] == nil then a[2]="" end
 
573
                        if (string.match(a[1], "file") ~= nil) then
 
574
                                -- ignore
 
575
                        else
 
576
                                -- TODO. should store everything! (but no reopen :O)
 
577
                                if (string.match(a[1], "asm") ~= nil) 
 
578
                                or (string.match(a[1], "scr") ~= nil) then
 
579
                                        Radare_Config_storage[a[1]] = a[2]
 
580
                                        Radare_Config_storage[a[1]] = a[2]
 
581
                                end
 
582
                        end
 
583
                end
 
584
        end
 
585
end
 
586
 
 
587
function Radare.Config.restore()
 
588
        for a,b in pairs(Radare_Config_storage) do
 
589
                Radare.Config.set(a,b)
 
590
        --      print (a.." = "..b)
 
591
        end
 
592
end
 
593
 
 
594
function Radare.Config.set(key, val)
 
595
        r.cmd("eval "..key.."="..val)
 
596
        return val
 
597
end
 
598
 
 
599
function Radare.Config.color(value)
 
600
        r.cmd("eval scr.color ="..value)
 
601
        return value
 
602
end
 
603
 
 
604
function Radare.Config.get(key)
 
605
        return r.cmd("eval "..key)
 
606
end
 
607
 
 
608
function Radare.Config.limit(sizs)
 
609
        return r.cmd("eval cfg.limit = "..size)
 
610
end
 
611
 
 
612
-- crypto stuff
 
613
 
 
614
function Radare.Hash.md5(size, address)
 
615
        if size == nil then size = "" end
 
616
        if address == nil then return r.cmd("#md5 "..size) end
 
617
        return r.cmd("#md5 "..size.."@"..address)
 
618
end
 
619
 
 
620
function Radare.Hash.crc32(size, address)
 
621
        if size == nil then size = "" end
 
622
        if address == nil then return r.cmd("#crc32 "..size) end
 
623
        return r.cmd("#crc32 "..size.."@"..address)
 
624
end
 
625
 
 
626
function Radare.Hash.md4(size, address)
 
627
        if size == nil then size = "" end
 
628
        if address == nil then return r.cmd("#md4 "..size) end
 
629
        return r.cmd("#md4 "..size.."@"..address)
 
630
end
 
631
 
 
632
function Radare.Hash.sha1(size, address)
 
633
        if size == nil then size = "" end
 
634
        if address == nil then return r.cmd("#sha1 "..size) end
 
635
        return r.cmd("#sha1 "..size.."@"..address)
 
636
end
 
637
 
 
638
function Radare.Hash.sha256(size, address)
 
639
        if size == nil then size = "" end
 
640
        if address == nil then return r.cmd("#sha256 "..size) end
 
641
        return r.cmd("#sha256 "..size.."@"..address)
 
642
end
 
643
 
 
644
function Radare.Hash.sha384(size, address)
 
645
        if size == nil then size = "" end
 
646
        if address == nil then return r.cmd("#sha384 "..size) end
 
647
        return r.cmd("#sha384 "..size.."@"..address)
 
648
end
 
649
 
 
650
function Radare.Hash.sha512(size, address)
 
651
        if size == nil then size = "" end
 
652
        if address == nil then return r.cmd("#sha512 "..size) end
 
653
        return r.cmd("#sha512 "..size.."@"..address)
 
654
end
 
655
 
 
656
function Radare.Hash.hash(algo, size, address)
 
657
        if size == nil then size = "" end
 
658
        eval("#"..algo.." "..size)
 
659
end
 
660
 
 
661
function Radare.Hash.sha512(size, address)
 
662
        return hash("sha512", size, address)
 
663
        --if size == nil then size = "" end
 
664
        --if address == nil then return r.cmd("#sha512 "..size) end
 
665
        --return r.cmd("#sha512 "..size.."@"..address)
 
666
end
 
667
 
 
668
-- code api
 
669
function Radare.Code.comment(offset, message)
 
670
        -- TODO: if only offset passed, return comment string
 
671
        r.cmd("CC "..message.." @ "..offset)
 
672
        return Radare.Code
 
673
end
 
674
 
 
675
function Radare.Code.code(offset, len)
 
676
        r.cmd("Cc "..len.." @ "..offset)
 
677
        return Radare.Code
 
678
end
 
679
 
 
680
function Radare.Code.data(offset, len)
 
681
        r.cmd("Cd "..len.." @ "..offset)
 
682
        return Radare.Code
 
683
end
 
684
 
 
685
function Radare.Code.string(offset, len)
 
686
        r.cmd("Cs "..len.." @ "..offset)
 
687
        return Radare.Code
 
688
end
 
689
 
 
690
-- change a signal handler of the child process
 
691
function Radare.Debugger.signal(signum, sighandler)
 
692
        r.cmd("!signal "..signum.." "..sighandler)
 
693
        return Radare.Debugger
 
694
end
 
695
 
 
696
function Radare.Debugger.bp_remove(address)
 
697
        r.cmd("!bp -"..address);
 
698
        return Radare.Debugger
 
699
end
 
700
 
 
701
function Radare.Debugger.continue(address)
 
702
        if address == nil then
 
703
                r.cmd("!cont"); 
 
704
        else
 
705
                r.cmd("!cont "..address);
 
706
        end
 
707
        return Radare.Debugger
 
708
end
 
709
 
 
710
function Radare.Debugger.step(num)
 
711
        r.cmd("!step "..num)
 
712
        return Radare.Debugger
 
713
end
 
714
 
 
715
function Radare.Debugger.step(num)
 
716
        r.cmd("!step "..num)
 
717
        return Radare.Debugger
 
718
end
 
719
 
 
720
function Radare.Debugger.step_over()
 
721
        r.cmd("!stepo");
 
722
        return Radare.Debugger
 
723
end
 
724
 
 
725
function Radare.Debugger.step_until_user_code()
 
726
        r.cmd("!stepu");
 
727
        return Radare.Debugger
 
728
end
 
729
 
 
730
function Radare.Debugger.add_bp(addr)
 
731
        r.cmd("!bp "..addr)
 
732
        return Radare.Debugger
 
733
end
 
734
 
 
735
function Radare.Debugger.remove_bp(addr)
 
736
        r.cmd("!bp -"..addr)
 
737
        return Radare.Debugger
 
738
end
 
739
 
 
740
function Radare.Debugger.alloc(size)
 
741
        return cmd_str("!alloc "..size)
 
742
end
 
743
 
 
744
function Radare.Debugger.free(addr) -- rename to dealloc?
 
745
        return cmd_str("!free "..addr)
 
746
end
 
747
 
 
748
function Radare.Debugger.dump(dirname)
 
749
        r.cmd("!dump "..dirname)
 
750
        return Radare.Debugger
 
751
end
 
752
 
 
753
function Radare.Debugger.restore(dirname)
 
754
        r.cmd("!restore "..dirname)
 
755
        return Radare.Debugger
 
756
end
 
757
 
 
758
function Radare.Debugger.jump(addr)
 
759
        r.cmd("!jmp "..addr)
 
760
        return Radare.Debugger
 
761
end
 
762
 
 
763
function Radare.Debugger.backtrace()
 
764
        local res = split(Radare.cmd("!bt"),"\n")
 
765
        local ret = {}
 
766
        for i = 1, #res do
 
767
                local line = split(res[i], " ")
 
768
                ret[i] = line[2]
 
769
        end
 
770
        return ret;
 
771
end
 
772
 
 
773
print "[radare.lua] Type 'help()' or 'quit' to return to radare shell."