source: zzuf/trunk/src/zzuf.c @ 1650

Last change on this file since 1650 was 1650, checked in by Sam Hocevar, 14 years ago
  • Don't stop if the process was killed by us.
  • Property svn:keywords set to Id
File size: 22.5 KB
Line 
1/*
2 *  zzuf - general purpose fuzzer
3 *  Copyright (c) 2002, 2007 Sam Hocevar <sam@zoy.org>
4 *                All Rights Reserved
5 *
6 *  $Id: zzuf.c 1650 2007-01-11 22:11:28Z sam $
7 *
8 *  This program is free software. It comes without any warranty, to
9 *  the extent permitted by applicable law. You can redistribute it
10 *  and/or modify it under the terms of the Do What The Fuck You Want
11 *  To Public License, Version 2, as published by Sam Hocevar. See
12 *  http://sam.zoy.org/wtfpl/COPYING for more details.
13 */
14
15/*
16 *  main.c: main program
17 */
18
19#include "config.h"
20
21#if defined HAVE_STDINT_H
22#   include <stdint.h>
23#elif defined HAVE_INTTYPES_H
24#   include <inttypes.h>
25#endif
26#if defined(HAVE_GETOPT_H)
27#   include <getopt.h>
28#endif
29#include <stdio.h>
30#include <stdlib.h>
31#include <unistd.h>
32#include <regex.h>
33#include <string.h>
34#include <errno.h>
35#include <signal.h>
36#include <sys/time.h>
37#include <time.h>
38#include <sys/wait.h>
39#include <sys/time.h>
40#include <sys/resource.h>
41
42#include "libzzuf.h"
43#include "random.h"
44#include "fd.h"
45#include "fuzz.h"
46#include "md5.h"
47
48static void spawn_child(char **);
49static void clean_children(void);
50static void read_children(void);
51
52static char *merge_regex(char *, char *);
53static char *merge_file(char *, char *);
54static void set_environment(char const *);
55static void version(void);
56#if defined(HAVE_GETOPT_H)
57static void usage(void);
58#endif
59
60static struct child_list
61{
62    enum status
63    {
64        STATUS_FREE,
65        STATUS_RUNNING,
66        STATUS_SIGTERM,
67        STATUS_SIGKILL,
68        STATUS_EOF,
69    } status;
70
71    pid_t pid;
72    int fd[3]; /* 0 is debug, 1 is stderr, 2 is stdout */
73    int bytes, seed;
74    time_t date;
75    struct md5 *ctx;
76} *child_list;
77static int maxforks = 1, child_count = 0, maxcrashes = 1, crashes = 0;
78
79static int seed = 0;
80static int endseed = 1;
81static int quiet = 0;
82static int maxbytes = -1;
83static int md5 = 0;
84static int checkexit = 0;
85static int maxmem = -1;
86static double maxtime = -1.0;
87
88#define ZZUF_FD_SET(fd, p_fdset, maxfd) \
89    if(fd >= 0) \
90    { \
91        FD_SET(fd, p_fdset); \
92        if(fd > maxfd) \
93            maxfd = fd; \
94    }
95
96#define ZZUF_FD_ISSET(fd, p_fdset) \
97    ((fd >= 0) && (FD_ISSET(fd, p_fdset)))
98
99int main(int argc, char *argv[])
100{
101    char **newargv;
102    char *parser, *include, *exclude, *protect, *refuse;
103    int i, cmdline = 0;
104
105    include = exclude = protect = refuse = NULL;
106
107#if defined(HAVE_GETOPT_H)
108    for(;;)
109    {
110#   ifdef HAVE_GETOPT_LONG
111#       define MOREINFO "Try `%s --help' for more information.\n"
112        int option_index = 0;
113        static struct option long_options[] =
114        {
115            /* Long option, needs arg, flag, short option */
116            { "max-bytes",   1, NULL, 'B' },
117            { "cmdline",     0, NULL, 'c' },
118            { "max-crashes", 1, NULL, 'C' },
119            { "debug",       0, NULL, 'd' },
120            { "exclude",     1, NULL, 'E' },
121            { "max-forks",   1, NULL, 'F' },
122            { "stdin",       0, NULL, 'i' },
123            { "include",     1, NULL, 'I' },
124            { "md5",         0, NULL, 'm' },
125            { "max-memory",  1, NULL, 'M' },
126            { "network",     0, NULL, 'n' },
127            { "protect",     1, NULL, 'P' },
128            { "quiet",       0, NULL, 'q' },
129            { "ratio",       1, NULL, 'r' },
130            { "refuse",      1, NULL, 'R' },
131            { "seed",        1, NULL, 's' },
132            { "signal",      0, NULL, 'S' },
133            { "max-time",    1, NULL, 'T' },
134            { "check-exit",  0, NULL, 'x' },
135            { "help",        0, NULL, 'h' },
136            { "version",     0, NULL, 'v' },
137        };
138        int c = getopt_long(argc, argv, "B:cC:dE:F:iI:mM:nP:qr:R:s:ST:xhv",
139                            long_options, &option_index);
140#   else
141#       define MOREINFO "Try `%s -h' for more information.\n"
142        int c = getopt(argc, argv, "B:cC:dE:F:iI:mM:nP:qr:R:s:ST:xhv");
143#   endif
144        if(c == -1)
145            break;
146
147        switch(c)
148        {
149        case 'B': /* --max-bytes */
150            maxbytes = atoi(optarg);
151            break;
152        case 'c': /* --cmdline */
153            cmdline = 1;
154            break;
155        case 'C': /* --max-crashes */
156            maxcrashes = atoi(optarg);
157            if(maxcrashes <= 0)
158                maxcrashes = 0;
159            break;
160        case 'd': /* --debug */
161            setenv("ZZUF_DEBUG", "1", 1);
162            break;
163        case 'E': /* --exclude */
164            exclude = merge_regex(exclude, optarg);
165            if(!exclude)
166            {
167                printf("%s: invalid regex -- `%s'\n", argv[0], optarg);
168                return EXIT_FAILURE;
169            }
170            break;
171        case 'F': /* --max-forks */
172            maxforks = atoi(optarg) > 1 ? atoi(optarg) : 1;
173            break;
174        case 'i': /* --stdin */
175            setenv("ZZUF_STDIN", "1", 1);
176            break;
177        case 'I': /* --include */
178            include = merge_regex(include, optarg);
179            if(!include)
180            {
181                printf("%s: invalid regex -- `%s'\n", argv[0], optarg);
182                return EXIT_FAILURE;
183            }
184            break;
185        case 'm': /* --md5 */
186            md5 = 1;
187            break;
188        case 'M': /* --max-memory */
189            setenv("ZZUF_MEMORY", "1", 1);
190            maxmem = atoi(optarg);
191            break;
192        case 'n': /* --network */
193            setenv("ZZUF_NETWORK", "1", 1);
194            break;
195        case 'P': /* --protect */
196            protect = optarg;
197            break;
198        case 'q': /* --quiet */
199            quiet = 1;
200            break;
201        case 'r': /* --ratio */
202            setenv("ZZUF_RATIO", optarg, 1);
203            _zz_setratio(atof(optarg));
204            break;
205        case 'R': /* --refuse */
206            refuse = optarg;
207            break;
208        case 's': /* --seed */
209            parser = strchr(optarg, ':');
210            _zz_setseed(seed = atol(optarg));
211            endseed = parser ? atoi(parser + 1) : seed + 1;
212            break;
213        case 'S': /* --signal */
214            setenv("ZZUF_SIGNAL", "1", 1);
215            break;
216        case 'T': /* --max-time */
217            maxtime = atof(optarg);
218            break;
219        case 'x': /* --check-exit */
220            checkexit = 1;
221            break;
222        case 'h': /* --help */
223            usage();
224            return 0;
225        case 'v': /* --version */
226            version();
227            return 0;
228        default:
229            printf("%s: invalid option -- %c\n", argv[0], c);
230            printf(MOREINFO, argv[0]);
231            return EXIT_FAILURE;
232        }
233    }
234#else
235#   define MOREINFO "Usage: %s message...\n"
236    int optind = 1;
237#endif
238
239    /* If asked to read from the standard input */
240    if(optind >= argc)
241    {
242        uint8_t md5sum[16];
243        struct md5 *ctx = NULL;
244
245        if(md5)
246            ctx = _zz_md5_init();
247
248        if(endseed != seed + 1)
249        {
250            printf("%s: seed ranges are incompatible with stdin fuzzing\n",
251                   argv[0]);
252            printf(MOREINFO, argv[0]);
253            return EXIT_FAILURE;
254        }
255
256        if(protect)
257            _zz_protect(protect);
258        if(refuse)
259            _zz_refuse(refuse);
260
261        _zz_fd_init();
262        _zz_register(0);
263
264        for(;;)
265        {
266            uint8_t buf[12];
267            int ret = fread(buf, 1, 12, stdin);
268            if(ret <= 0)
269                break;
270
271            _zz_fuzz(0, buf, ret);
272            _zz_addpos(0, ret);
273
274            if(md5)
275                _zz_md5_add(ctx, buf, ret);
276            else
277                fwrite(buf, 1, ret, stdout);
278        }
279
280        if(md5)
281        {
282            _zz_md5_fini(md5sum, ctx);
283            fprintf(stdout, "zzuf[seed=%i]: %.02x%.02x%.02x%.02x%.02x%.02x"
284                    "%.02x%.02x%.02x%.02x%.02x%.02x%.02x%.02x%.02x%.02x\n",
285                    seed, md5sum[0], md5sum[1], md5sum[2], md5sum[3],
286                    md5sum[4], md5sum[5], md5sum[6], md5sum[7],
287                    md5sum[8], md5sum[9], md5sum[10], md5sum[11],
288                    md5sum[12], md5sum[13], md5sum[14], md5sum[15]);
289            fflush(stdout);
290        }
291
292        _zz_unregister(0);
293        _zz_fd_fini();
294
295        return EXIT_SUCCESS;
296    }
297
298    if(cmdline)
299    {
300        int dashdash = 0;
301
302        for(i = optind + 1; i < argc; i++)
303        {
304            if(dashdash)
305                include = merge_file(include, argv[i]);
306            else if(!strcmp("--", argv[i]))
307                dashdash = 1;
308            else if(argv[i][0] != '-')
309                include = merge_file(include, argv[i]);
310        }
311    }
312
313    if(include)
314        setenv("ZZUF_INCLUDE", include, 1);
315    if(exclude)
316        setenv("ZZUF_EXCLUDE", exclude, 1);
317    if(protect)
318        setenv("ZZUF_PROTECT", protect, 1);
319    if(refuse)
320        setenv("ZZUF_REFUSE", refuse, 1);
321
322    /* Allocate memory for children handling */
323    child_list = malloc(maxforks * sizeof(struct child_list));
324    for(i = 0; i < maxforks; i++)
325        child_list[i].status = STATUS_FREE;
326    child_count = 0;
327
328    /* Preload libzzuf.so */
329    set_environment(argv[0]);
330
331    /* Create new argv */
332    newargv = malloc((argc - optind + 1) * sizeof(char *));
333    memcpy(newargv, argv + optind, (argc - optind) * sizeof(char *));
334    newargv[argc - optind] = (char *)NULL;
335
336    /* Main loop */
337    while(child_count || seed < endseed)
338    {
339        /* Spawn one new child, if necessary */
340        if(child_count < maxforks && seed < endseed &&
341                             (maxcrashes && crashes < maxcrashes))
342            spawn_child(newargv);
343
344        /* Cleanup dead or dying children */
345        clean_children();
346
347        /* Read data from children */
348        read_children();
349
350        if(maxcrashes && crashes >= maxcrashes && child_count == 0)
351            break;
352    }
353
354    /* Clean up */
355    free(newargv);
356    free(child_list);
357
358    return EXIT_SUCCESS;   
359}
360
361static char *merge_file(char *regex, char *file)
362{
363    char *newfile = malloc(1 + 2 * strlen(file) + 1 + 1), *tmp = newfile;
364
365    *tmp++ = '^';
366    while(*file)
367    {
368        if(strchr("^.[$()|*+?{\\", *file))
369            *tmp++ = '\\';
370        *tmp++ = *file++;
371    }
372    *tmp++ = '$';
373    *tmp++ = '\0';
374
375    tmp = merge_regex(regex, newfile);
376    free(newfile);
377    return tmp;
378}
379
380static char *merge_regex(char *regex, char *string)
381{
382    regex_t optre;
383
384    if(regex)
385    {
386        regex = realloc(regex, strlen(regex) + strlen(string) + 1 + 1);
387        sprintf(regex + strlen(regex) - 1, "|%s)", string);
388    }
389    else
390    {
391        regex = malloc(1 + strlen(string) + 1 + 1);
392        sprintf(regex, "(%s)", string);
393    }
394
395    if(regcomp(&optre, regex, REG_EXTENDED) != 0)
396    {
397        free(regex);
398        return NULL;
399    }
400    regfree(&optre);
401
402    return regex;
403}
404
405static void spawn_child(char **argv)
406{
407    static int const files[] = { DEBUG_FILENO, STDERR_FILENO, STDOUT_FILENO };
408    char buf[BUFSIZ];
409    int fd[3][2];
410    pid_t pid;
411    int i, j;
412
413    /* Find the empty slot */
414    for(i = 0; i < maxforks; i++)
415        if(child_list[i].status == STATUS_FREE)
416            break;
417
418    /* Prepare communication pipe */
419    for(j = 0; j < 3; j++)
420        if(pipe(fd[j]) == -1)
421        {
422            perror("pipe");
423            return;
424        }
425
426    /* Fork and launch child */
427    pid = fork();
428    switch(pid)
429    {
430        case -1:
431            perror("fork");
432            return;
433        case 0:
434            /* We’re the child */
435            if(maxmem >= 0)
436            {
437                struct rlimit rlim;
438                rlim.rlim_cur = maxmem * 1000000;
439                rlim.rlim_max = maxmem * 1000000;
440                setrlimit(RLIMIT_AS, &rlim);
441            }
442
443            for(j = 0; j < 3; j++)
444            {
445                close(fd[j][0]);
446                dup2(fd[j][1], files[j]);
447                close(fd[j][1]);
448            }
449
450            /* Set environment variables */
451            sprintf(buf, "%i", seed);
452            setenv("ZZUF_SEED", buf, 1);
453
454            /* Run our process */
455            if(execvp(argv[0], argv))
456            {
457                perror(argv[0]);
458                exit(EXIT_FAILURE);
459            }
460            return;
461    }
462
463    /* We’re the parent, acknowledge spawn */
464    child_list[i].date = time(NULL);
465    child_list[i].pid = pid;
466    for(j = 0; j < 3; j++)
467    {
468        close(fd[j][1]);
469        child_list[i].fd[j] = fd[j][0];
470    }
471    child_list[i].bytes = 0;
472    child_list[i].seed = seed;
473    child_list[i].status = STATUS_RUNNING;
474    if(md5)
475        child_list[i].ctx = _zz_md5_init();
476    child_count++;
477    seed++;
478}
479
480static void clean_children(void)
481{
482    time_t now = time(NULL);
483    int i, j;
484
485    /* Terminate children if necessary */
486    for(i = 0; i < maxforks; i++)
487    {
488        if(child_list[i].status == STATUS_RUNNING
489            && maxbytes >= 0 && child_list[i].bytes > maxbytes)
490        {
491            fprintf(stdout, "zzuf[seed=%i]: data exceeded, sending SIGTERM\n",
492                    child_list[i].seed);
493            kill(child_list[i].pid, SIGTERM);
494            child_list[i].date = now;
495            child_list[i].status = STATUS_SIGTERM;
496        }
497
498        if(child_list[i].status == STATUS_RUNNING
499            && maxtime >= 0.0
500            && difftime(now, child_list[i].date) > maxtime)
501        {
502            fprintf(stdout, "zzuf[seed=%i]: time exceeded, sending SIGTERM\n",
503                    child_list[i].seed);
504            kill(child_list[i].pid, SIGTERM);
505            child_list[i].date = now;
506            child_list[i].status = STATUS_SIGTERM;
507        }
508    }
509
510    /* Kill children if necessary */
511    for(i = 0; i < maxforks; i++)
512    {
513        if(child_list[i].status == STATUS_SIGTERM
514            && difftime(now, child_list[i].date) > 2.0)
515        {
516            fprintf(stdout, "zzuf[seed=%i]: not responding, sending SIGKILL\n",
517                    child_list[i].seed);
518            kill(child_list[i].pid, SIGKILL);
519            child_list[i].status = STATUS_SIGKILL;
520        }
521    }
522
523    /* Collect dead children */
524    for(i = 0; i < maxforks; i++)
525    {
526        uint8_t md5sum[16];
527        int status;
528        pid_t pid;
529
530        if(child_list[i].status != STATUS_SIGKILL
531            && child_list[i].status != STATUS_SIGTERM
532            && child_list[i].status != STATUS_EOF)
533            continue;
534
535        pid = waitpid(child_list[i].pid, &status, WNOHANG);
536        if(pid <= 0)
537            continue;
538
539        if(checkexit && WIFEXITED(status) && WEXITSTATUS(status))
540        {
541            fprintf(stdout, "zzuf[seed=%i]: exit %i\n",
542                    child_list[i].seed, WEXITSTATUS(status));
543            crashes++;
544        }
545        else if(WIFSIGNALED(status)
546                 && !(WTERMSIG(status) == SIGTERM
547                       && child_list[i].status == STATUS_SIGTERM))
548        {
549            fprintf(stdout, "zzuf[seed=%i]: signal %i%s\n",
550                    child_list[i].seed, WTERMSIG(status),
551                      (WTERMSIG(status) == SIGKILL && maxmem >= 0) ?
552                      " (memory exceeded?)" : "");
553            crashes++;
554        }
555
556        for(j = 0; j < 3; j++)
557            if(child_list[i].fd[j] >= 0)
558                close(child_list[i].fd[j]);
559
560        if(md5)
561        {
562            _zz_md5_fini(md5sum, child_list[i].ctx);
563            fprintf(stdout, "zzuf[seed=%i]: %.02x%.02x%.02x%.02x%.02x%.02x"
564                    "%.02x%.02x%.02x%.02x%.02x%.02x%.02x%.02x%.02x%.02x\n",
565                    child_list[i].seed, md5sum[0], md5sum[1], md5sum[2],
566                    md5sum[3], md5sum[4], md5sum[5], md5sum[6], md5sum[7],
567                    md5sum[8], md5sum[9], md5sum[10], md5sum[11], md5sum[12],
568                    md5sum[13], md5sum[14], md5sum[15]);
569        }
570        child_list[i].status = STATUS_FREE;
571        child_count--;
572    }
573
574    fflush(stdout);
575}
576
577static void read_children(void)
578{
579    struct timeval tv;
580    fd_set fdset;
581    int i, j, ret, maxfd = 0;
582
583    /* Read data from all sockets */
584    FD_ZERO(&fdset);
585    for(i = 0; i < maxforks; i++)
586    {
587        if(child_list[i].status != STATUS_RUNNING)
588            continue;
589
590        for(j = 0; j < 3; j++)
591            ZZUF_FD_SET(child_list[i].fd[j], &fdset, maxfd);
592    }
593    tv.tv_sec = 0;
594    tv.tv_usec = 1000;
595
596    ret = select(maxfd + 1, &fdset, NULL, NULL, &tv);
597    if(ret < 0)
598        perror("select");
599    if(ret <= 0)
600        return;
601
602    /* XXX: cute (i, j) iterating hack */
603    for(i = 0, j = 0; i < maxforks; i += (j == 2), j = (j + 1) % 3)
604    {
605        uint8_t buf[BUFSIZ];
606
607        if(child_list[i].status != STATUS_RUNNING)
608            continue;
609
610        if(!ZZUF_FD_ISSET(child_list[i].fd[j], &fdset))
611            continue;
612
613        ret = read(child_list[i].fd[j], buf, BUFSIZ - 1);
614        if(ret > 0)
615        {
616            /* We got data */
617            if(j != 0)
618                child_list[i].bytes += ret;
619
620            if(md5 && j == 2)
621                _zz_md5_add(child_list[i].ctx, buf, ret);
622            else if(!quiet || j == 0)
623                write((j < 2) ? STDERR_FILENO : STDOUT_FILENO, buf, ret);
624        }
625        else if(ret == 0)
626        {
627            /* End of file reached */
628            close(child_list[i].fd[j]);
629            child_list[i].fd[j] = -1;
630
631            if(child_list[i].fd[0] == -1 && child_list[i].fd[1] == -1
632               && child_list[i].fd[2] == -1)
633                child_list[i].status = STATUS_EOF;
634        }
635    }
636}
637
638static void set_environment(char const *progpath)
639{
640    char *libpath, *tmp;
641    int ret, len = strlen(progpath);
642#if defined __APPLE__
643#   define FILENAME "libzzuf.dylib"
644#   define EXTRAINFO ""
645#   define PRELOAD "DYLD_INSERT_LIBRARIES"
646    setenv("DYLD_FORCE_FLAT_NAMESPACE", "1", 1);
647#elif defined __osf__
648#   define FILENAME "libzzuf.so"
649#   define EXTRAINFO ":DEFAULT"
650#   define PRELOAD "_RLD_LIST"
651#else
652#   define FILENAME "libzzuf.so"
653#   define EXTRAINFO ""
654#   define PRELOAD "LD_PRELOAD"
655#endif
656
657    libpath = malloc(len + strlen("/.libs/" FILENAME EXTRAINFO) + 1);
658    strcpy(libpath, progpath);
659
660    tmp = strrchr(libpath, '/');
661    strcpy(tmp ? tmp + 1 : libpath, ".libs/" FILENAME);
662    ret = access(libpath, R_OK);
663
664    strcpy(tmp ? tmp + 1 : libpath, ".libs/" FILENAME EXTRAINFO);
665    if(ret == 0)
666        setenv(PRELOAD, libpath, 1);
667    else
668        setenv(PRELOAD, LIBDIR "/" FILENAME EXTRAINFO, 1);
669    free(libpath);
670}
671
672static void version(void)
673{
674    printf("zzuf %s\n", VERSION);
675    printf("Copyright (C) 2002, 2007 Sam Hocevar <sam@zoy.org>\n");
676    printf("This is free software.  You may redistribute copies of it under the\n");
677    printf("terms of the Do What The Fuck You Want To Public License, Version 2\n");
678    printf("<http://sam.zoy.org/wtfpl/>.\n");
679    printf("There is NO WARRANTY, to the extent permitted by law.\n");
680    printf("\n");
681    printf("Written by Sam Hocevar. Report bugs to <sam@zoy.org>.\n");
682}
683
684#if defined(HAVE_GETOPT_H)
685static void usage(void)
686{
687    printf("Usage: zzuf [-cdimnqSx] [-r ratio] [-s seed | -s start:stop]\n");
688    printf("                        [-F forks] [-C crashes] [-B bytes] [-T seconds]\n");
689    printf("                        [-M bytes] [-P protect] [-R refuse]\n");
690    printf("                        [-I include] [-E exclude] [PROGRAM [ARGS]...]\n");
691#   ifdef HAVE_GETOPT_LONG
692    printf("       zzuf -h | --help\n");
693    printf("       zzuf -v | --version\n");
694#   else
695    printf("       zzuf -h\n");
696    printf("       zzuf -v\n");
697#   endif
698    printf("Run COMMAND and randomly fuzz its input.\n");
699    printf("\n");
700    printf("Mandatory arguments to long options are mandatory for short options too.\n");
701#   ifdef HAVE_GETOPT_LONG
702    printf("  -B, --max-bytes <n>      kill children that output more than <n> bytes\n");
703    printf("  -c, --cmdline            only fuzz files specified in the command line\n");
704    printf("  -C, --max-crashes <n>    stop after <n> children have crashed (default 1)\n");
705    printf("  -d, --debug              print debug messages\n");
706    printf("  -E, --exclude <regex>    do not fuzz files matching <regex>\n");
707    printf("  -F, --max-forks <n>      number of concurrent children (default 1)\n");
708    printf("  -i, --stdin              fuzz standard input\n");
709    printf("  -I, --include <regex>    only fuzz files matching <regex>\n");
710    printf("  -m, --md5                compute the output's MD5 hash\n");
711    printf("  -M, --max-memory <n>     maximum child virtual memory size in MB\n");
712    printf("  -n, --network            fuzz network input\n");
713    printf("  -P, --protect <list>     protect bytes and characters in <list>\n");
714    printf("  -q, --quiet              do not print children's messages\n");
715    printf("  -r, --ratio <ratio>      bit fuzzing ratio (default 0.004)\n");
716    printf("  -R, --refuse <list>      refuse bytes and characters in <list>\n");
717    printf("  -s, --seed <seed>        random seed (default 0)\n");
718    printf("      --seed <start:stop>  specify a seed range\n");
719    printf("  -S, --signal             prevent children from diverting crashing signals\n");
720    printf("  -T, --max-time <n>       kill children that run for more than <n> seconds\n");
721    printf("  -x, --check-exit         report processes that exit with a non-zero status\n");
722    printf("  -h, --help               display this help and exit\n");
723    printf("  -v, --version            output version information and exit\n");
724#   else
725    printf("  -B <n>           kill children that output more than <n> bytes\n");
726    printf("  -c               only fuzz files specified in the command line\n");
727    printf("  -C <n>           stop after <n> children have crashed (default 1)\n");
728    printf("  -d               print debug messages\n");
729    printf("  -E <regex>       do not fuzz files matching <regex>\n");
730    printf("  -F <n>           number of concurrent forks (default 1)\n");
731    printf("  -i               fuzz standard input\n");
732    printf("  -I <regex>       only fuzz files matching <regex>\n");
733    printf("  -m               compute the output's MD5 hash\n");
734    printf("  -M               maximum child virtual memory size in MB\n");
735    printf("  -n               fuzz network input\n");
736    printf("  -P <list>        protect bytes and characters in <list>\n");
737    printf("  -q               do not print the fuzzed application's messages\n");
738    printf("  -r <ratio>       bit fuzzing ratio (default 0.004)\n");
739    printf("  -R <list>        refuse bytes and characters in <list>\n");
740    printf("  -s <seed>        random seed (default 0)\n");
741    printf("     <start:stop>  specify a seed range\n");
742    printf("  -S               prevent children from diverting crashing signals\n");
743    printf("  -T <n>           kill children that run for more than <n> seconds\n");
744    printf("  -x               report processes that exit with a non-zero status\n");
745    printf("  -h               display this help and exit\n");
746    printf("  -v               output version information and exit\n");
747#   endif
748    printf("\n");
749    printf("Written by Sam Hocevar. Report bugs to <sam@zoy.org>.\n");
750}
751#endif
752
Note: See TracBrowser for help on using the repository browser.