← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/search.c

  • 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:
src/search.c
35
35
 
36
36
static int nhit = 0;
37
37
 
38
 
static void search_alarm()
39
 
{
40
 
        progressbar((int)(config.seek/config.size*100));  // slowdowns 170%
 
38
static void search_alarm() {
 
39
        progressbar(nhit, config.seek, config.size);
41
40
#if __UNIX__
42
41
        go_alarm(search_alarm);
43
42
#endif
44
43
}
45
44
 
46
 
static int hit_idx = 0;
 
45
static int hit_idx = 1;
47
46
 
48
47
void radare_search_seek_hit(int idx)
49
48
{
50
49
        flag_t *flag;
51
50
        char buf[64];
52
51
 
53
 
        //sprintf(buf, "hit0_%d", hit_idx);
54
52
        radare_flag_name (buf, 0, hit_idx);
55
53
 
56
54
        flag = flag_get(buf);
58
56
        if (flag == NULL) {
59
57
                if (idx>0)
60
58
                        hit_idx -= idx;
61
 
                else    hit_idx += idx*2;
62
59
        } else radare_seek(flag->offset, SEEK_SET);
63
60
 
64
61
        hit_idx += idx;
65
 
        if (hit_idx<0) hit_idx=0;
 
62
        if (hit_idx<1) hit_idx=1;
66
63
}
67
64
 
68
65
int memcmpdiff(const u8 *a, const u8 *b, int len)
109
106
// TODO: handle Control-C
110
107
void radare_search_aes()
111
108
{
112
 
        u64 oseek  = config.seek;
113
 
        u64 limit  = config.size;
 
109
        ut64 oseek  = config.seek;
 
110
        ut64 limit  = config.size;
114
111
        size_t bsize = config.block_size;
115
112
        int found = 0;
116
113
        int i;
142
139
 
143
140
int radare_search_asm(const char *str)
144
141
{
145
 
        eprintf("TODO\n");
 
142
        eprintf("TODO: radare_search_asm\n");
146
143
#if 0
147
 
        u64 seek = config.seek;
 
144
        ut64 seek = config.seek;
148
145
        radare_seek(seek);
149
146
#endif
150
147
        return 0;
154
151
 
155
152
int radare_flag_name(char *buf, int kw, int hn)
156
153
{
157
 
        int i;
158
 
        char *a, *f = config_get("search.flagname");
 
154
        const char *f = config_get("search.flagname");
 
155
        char *a;
159
156
        if (!f || !f[0])
160
157
                goto beach;
161
158
        a = strstr(f, "%d");
165
162
                a = strstr(a+2, "%");
166
163
                if (a) goto beach;
167
164
        } else goto beach;
168
 
        sprintf(buf, f, i, hn);
 
165
        sprintf(buf, f, kw, hn);
169
166
        return 1;
170
167
beach:
171
 
        sprintf(buf, "hit%d_%d", i, hn);
 
168
        sprintf(buf, "hit%d_%d", kw, hn);
172
169
        return 0;
173
170
}
174
171
 
175
 
static int radare_tsearch_callback(struct _tokenizer *t, int i, u64 where)
 
172
static int radare_tsearch_callback(struct _tokenizer *t, int i, ut64 where)
176
173
{
177
174
        char flag_name[128];
178
 
        u64 off = config.seek;
 
175
        ut64 off = config.seek;
179
176
 
180
177
        if (align != 0 && where%align != 0)
181
178
                return 1;
221
218
{
222
219
        FILE *fd;
223
220
        char *ptr, buf[4096], cmd[4096];
224
 
        int i,ret;
225
 
        u64 tmp = config.seek;
226
 
        tokenizer *t;
 
221
        //int i,ret;
 
222
        ut64 tmp = config.seek;
 
223
        //tokenizer *t;
227
224
 
228
225
        if (strchr(file, '?')) {
229
226
                cons_printf("Usage: /: file [file2] [file3] ...\n"
240
237
        }
241
238
        config_set("cfg.verbose", "false");
242
239
        while(!feof(fd) && !config.interrupted) {
243
 
                char *foo;
244
240
                /* read line */
245
241
                buf[0]='\0';
246
242
                fgets(buf, 4095, fd);
249
245
                ptr = strchr(buf, ' ');
250
246
                if (ptr) {
251
247
                        ptr[0]='\0';
252
 
                        
253
248
                        sprintf(cmd, "hit.%s_%%d%%d", buf);
254
249
                        config_set("search.flagname", cmd);
255
250
                        sprintf(cmd, ":/x %s", ptr+1);
288
283
 
289
284
int search_from_file(char *file)
290
285
{
291
 
        int i,ret;
292
 
        u64 tmp = config.seek;
 
286
        int i, ret;
 
287
        ut64 tmp = config.seek;
293
288
        tokenizer *t;
294
289
 
295
290
        if (strchr(file, '?')) {
336
331
        char str[128];
337
332
        int num = -1, num2 = -1;
338
333
        tokenizer *t;
339
 
        u64 tmp = config.seek;
340
 
        u64 search_from;
341
 
        u64 search_to;
342
 
        u64 limit;
 
334
        ut64 tmp = config.seek;
 
335
        ut64 search_from;
 
336
        ut64 search_to;
 
337
        ut64 limit;
343
338
        int range_n = 0;
344
339
        int f0 = 0;
345
 
        u64 s;
 
340
        ut64 s;
346
341
 
347
342
        if (range == NULL)
348
343
                return 0;
351
346
 
352
347
        // init stuff
353
348
        search_cmdhit = config_get("cmd.hit");
354
 
        search_count = (int)config_get_i("cfg.count");
355
 
        search_flag = (int)config_get("search.flag");
 
349
        search_count = (int)(size_t)config_get_i("cfg.count");
 
350
        search_flag = (int)(size_t)config_get("search.flag");
356
351
        search_from = config_get_i("search.from");
357
352
        search_to = config_get_i("search.to");
358
 
        search_verbose = (int)config_get("search.verbose");
 
353
        search_verbose = (int)(size_t)config_get("search.verbose");
359
354
 
360
 
if (config_get("search.inar")) {
361
 
        if (! ranges_get_n(range_n++, &search_from, &search_to)) {
362
 
                eprintf("No ranges defined\n");
363
 
                return 0;
 
355
        if (config_get("search.inar")) {
 
356
                if (! ranges_get_n(range_n++, &search_from, &search_to)) {
 
357
                        eprintf("No ranges defined\n");
 
358
                        return 0;
 
359
                }
 
360
                printf("Searching using ranges...\n");
364
361
        }
365
 
        printf("Searching using ranges...\n");
366
 
}
367
362
        // twice
 
363
        hit_idx = 1; // reset hit index
368
364
        radare_cmd("f -hit0_*", 0);
369
365
        radare_cmd("f -hit0_*", 0);
370
366
        radare_cmd("fs search", 0);
371
 
do {
372
 
        nhit = 0;
373
 
        t = binparse_new(0);
374
 
        align = config_get_i("search.align");
375
 
        t->callback = &radare_tsearch_callback;
376
 
        len = strlen(range);
377
 
        // foreach token in range
378
 
        for(j=i=0;i<len;i++,j++) {
379
 
                str[j] = range[i];
380
 
                str[j+1] = '\0';
381
 
                switch(range[i+1]) {
382
 
                case '-':
383
 
                        num = atoi(str);
384
 
                        i++; j=-1;
385
 
                        f0=1;
386
 
                        break;
387
 
                case '\0':
388
 
                case ',':
389
 
                        if (str[0]=='\0') break;
390
 
                        num2 = atoi(str);
391
 
                        if (f0) {
392
 
                                f0=0;
393
 
                                if (num == -1) {
394
 
                                        printf("syntax error\n");
395
 
                                        break;
 
367
        do {
 
368
                nhit = 0;
 
369
                t = binparse_new(0);
 
370
                align = config_get_i("search.align");
 
371
                t->callback = &radare_tsearch_callback;
 
372
                len = strlen(range);
 
373
                // foreach token in range
 
374
                for(j=i=0;i<len;i++,j++) {
 
375
                        str[j] = range[i];
 
376
                        str[j+1] = '\0';
 
377
                        switch(range[i+1]) {
 
378
                        case '-':
 
379
                                num = atoi(str);
 
380
                                i++; j=-1;
 
381
                                f0=1;
 
382
                                break;
 
383
                        case '\0':
 
384
                        case ',':
 
385
                                if (str[0]=='\0') break;
 
386
                                num2 = atoi(str);
 
387
                                if (f0) {
 
388
                                        f0=0;
 
389
                                        if (num == -1) {
 
390
                                                printf("syntax error\n");
 
391
                                                break;
 
392
                                        }
 
393
                                        for(j = num;j<=num2;j++)
 
394
                                                binparse_add_search(t, j);
 
395
                                } else  binparse_add_search(t, num2);
 
396
                                j=-1;
 
397
                                str[0]='\0';
 
398
                                i++;
 
399
                                break;
 
400
                        }
 
401
                }
 
402
#if __UNIX__
 
403
                go_alarm(search_alarm);
 
404
#endif
 
405
                /* search loop */
 
406
                radare_controlc();
 
407
                config.seek = search_from;
 
408
                limit = config.limit;
 
409
                if (search_to!=0)
 
410
                        limit = search_to;
 
411
 
 
412
                //D eprintf("Searching from 0x%08llx to 0x%08llx\n", search_from, (search_to==0)?-1:search_to);
 
413
                for(i=1, radare_read(0); !config.interrupted; i = radare_read(1)) {
 
414
                        s = config.seek;
 
415
                        if (i==0) {
 
416
                                //eprintf("read err at 0x%08llx\n", config.seek);
 
417
                                break;
 
418
                        }
 
419
                        if (limit && config.seek >= limit) break;
 
420
                        if (config.debug && config.seek == 0xFFFFFFFF) break;
 
421
                        for(i=0;!config.interrupted && i<config.block_size;i++) {
 
422
                                if (update_tlist(t, config.block[i], config.seek+i)) {
 
423
                                        config.seek = s;
 
424
                                        radare_read(0);
396
425
                                }
397
 
                                for(j = num;j<=num2;j++)
398
 
                                        binparse_add_search(t, j);
399
 
                        } else  binparse_add_search(t, num2);
400
 
                        j=-1;
401
 
                        str[0]='\0';
402
 
                        i++;
403
 
                        break;
404
 
                }
405
 
        }
406
 
 
407
 
#if __UNIX__
408
 
        go_alarm(search_alarm);
409
 
#endif
410
 
        /* search loop */
411
 
        radare_controlc();
412
 
        config.seek = search_from;
413
 
        limit = config.limit;
414
 
        if (search_to!=0)
415
 
                limit = search_to;
416
 
 
417
 
        //D eprintf("Searching from 0x%08llx to 0x%08llx\n", search_from, (search_to==0)?-1:search_to);
418
 
        for(i=1, radare_read(0); !config.interrupted; i = radare_read(1)) {
419
 
                s = config.seek;
420
 
                if (i==0) {
421
 
                        //eprintf("read err at 0x%08llx\n", config.seek);
422
 
                        break;
423
 
                }
424
 
                if (limit && config.seek >= limit) break;
425
 
                if (config.debug && config.seek == 0xFFFFFFFF) break;
426
 
                for(i=0;!config.interrupted && i<config.block_size;i++) {
427
 
                        if (update_tlist(t, config.block[i], config.seek+i)) {
428
 
                                config.seek = s;
429
 
                                radare_read(0);
430
426
                        }
 
427
                        config.seek = s;
431
428
                }
432
 
                config.seek = s;
433
 
        }
434
 
} while(config_get("search.inar") && ranges_get_n(range_n++, &search_from, &search_to));
 
429
        } while(config_get("search.inar") && ranges_get_n(range_n++, &search_from, &search_to));
435
430
        binparser_free(t);
436
431
#if __UNIX__
437
432
        go_alarm(SIG_IGN);