1 files changed, 357 insertions, 0 deletions

diff --git a/pathologist/src/pathologist/pathologist.c b/pathologist/src/pathologist/pathologist.c
new file mode 100644
index 0000000..305c3ce
--- /dev/null
+++ b/pathologist/src/pathologist/pathologist.c
@@ -0,0 +1,357 @@
+/*
+     This file is part of GNUnet.
+     (C) 2010, 2011 Christian Grothoff (and other contributing authors)
+
+     GNUnet is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published
+     by the Free Software Foundation; either version 3, or (at your
+     option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+
+/**
+ * @file pathologist/pathologist.c
+ * @brief Monkey Pathologist: automated debugging tool
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include "monkey_common.h"
+#include "action.h"
+#include "monkey_getopt_lib.h"
+
+static char *dumpFileName;
+static char *binaryName;
+static char *command;
+static char *binaryArgs;
+static char *emailAddress;
+static char *edbFilePath;
+static char *gdbBinaryPath;
+static char *valgrindBinaryPath;
+static char *inspectExpression;
+static char *inspectFunction;
+static int scopeDepth;
+static int reverseExecutionAllowed = MONKEY_NO;
+static int ret = 0;
+
+static int checkFileExistence(const char *filePath) {
+        struct stat statBuff;
+        if (0 == stat(filePath, &statBuff)) {
+                return MONKEY_YES;
+        }
+        return MONKEY_NO;
+}
+
+
+static int checkELF(const char *binaryPath) {
+        int ch;
+        const char ELF[5] = {0x7f, 'E', 'L', 'F', '\0'}; // ELF magic number
+        char inputArr[5];
+        FILE *filePtr;
+        filePtr = fopen(binaryPath, "r");
+        int i;
+
+        for (i = 0; i < 4; i++) {
+                ch = fgetc(filePtr);
+                if (EOF == ch) {
+                        return MONKEY_NO;
+                }
+                inputArr[i] = ch;
+        }
+        inputArr[4] = '\0';
+        if (strcmp(ELF, inputArr) == 0) {
+                return MONKEY_YES;
+        }
+        return MONKEY_NO;
+}
+/**
+ * Main function that will launch Pathologist's action api.
+*/
+static void run()
+{
+        int result;
+        struct MONKEY_ACTION_Context *cntxt;
+
+        /* Check files existence */
+        if (MONKEY_NO == checkFileExistence(binaryName)) {
+                fprintf(stderr, "Error: Target binary file does not exist.\n");
+                ret = 1;
+                return;
+        }
+
+        if (MONKEY_NO == checkFileExistence(edbFilePath)) {
+                fprintf(stderr, "Error: Expression database file does not exist.\n");
+                ret = 1;
+                return;
+        }
+
+        if (NULL != gdbBinaryPath &&
+                MONKEY_NO == checkFileExistence(gdbBinaryPath))
+        {
+                fprintf(stderr, "Error: gdb binary file does not exist.\n");
+                ret = 1;
+                return;
+                
+        }
+
+        if (NULL != valgrindBinaryPath &&
+                MONKEY_NO == checkFileExistence(valgrindBinaryPath))
+        {
+                fprintf(stderr, "Error: valgrind binary file does not exist.\n");
+                ret = 1;
+                return;
+        }
+
+        /* Check if the target program is and ELF binary */
+        if (MONKEY_NO == checkELF(binaryName)) {
+                FILE* targetProgramPipe;
+                char buffer[128];
+                ret = 1;
+
+                fprintf(stderr, "Target program is not an ELF. Pathologist will not debug the program.\n");
+                fprintf(stderr, "Pathologist will attempt to run the program normally.\n");
+
+                targetProgramPipe = popen(command, "r");
+                if (NULL == targetProgramPipe) {
+                        fprintf(stderr, "Target is not a binary.\n");
+                        return;
+                }
+                while(!feof(targetProgramPipe)) {
+                        if (NULL != fgets(buffer, 128, targetProgramPipe)) {
+                                fputs(buffer, stderr);
+                        }
+                }
+                pclose(targetProgramPipe);
+                return;
+        }
+
+        if (NULL == edbFilePath)
+        {
+                /* lookup a file named test.db in the working directory */
+                struct stat buf;
+                if (0 != stat ("test.db", &buf))
+                {
+                        fprintf( stderr,
+                        "Expression Database file was not provided as and argument, "
+                        "and there is no file named test.db in pathologist's working directory!\n");
+                        MONKEY_break (0);
+                        ret = 1;
+                        return;
+                }
+        }
+
+        if (NULL == dumpFileName)
+        {
+                /* if no file name provided for the output report, the default report name will be binaryName_PIDpid */
+                const char *bn = strrchr(binaryName, '/');
+                if (NULL == bn) {
+                        bn = binaryName;
+                } else {
+                        bn++;
+                }
+                MONKEY_asprintf(&dumpFileName, "%s_PID%d", bn, getpid());
+        }
+
+        /* Initialize context for the Action API */
+        cntxt = MONKEY_malloc (sizeof (struct MONKEY_ACTION_Context));
+        cntxt->email_address = emailAddress;
+        cntxt->binary_name = binaryName;
+        cntxt->binaryArgs = binaryArgs;
+        cntxt->expression_database_path = edbFilePath;
+        cntxt->gdb_binary_path = gdbBinaryPath;
+        cntxt->valgrind_binary_path = valgrindBinaryPath;
+        cntxt->inspect_expression = inspectExpression;
+        cntxt->inspect_function = inspectFunction;
+        cntxt->scope_depth = scopeDepth;
+        cntxt->bug_detected = NO_BUG_DETECTED;
+        cntxt->has_null = MONKEY_NO;
+        cntxt->xml_report_node = NULL;
+        cntxt->run_reverse = reverseExecutionAllowed;
+        cntxt->gdb_connected = MONKEY_NO;
+
+        result = MONKEY_ACTION_rerun_with_gdb (cntxt);
+        int retVal;
+        switch (result)
+        {
+        case MONKEY_NO:
+        case GDB_STATE_ERROR:
+                fprintf (stderr, "Error in using gdb. Pathologist will exit now!\n");
+                ret = 1;
+                break;
+        case GDB_STATE_EXIT_NORMALLY:
+                fprintf (stderr, "Debug with gdb, program exited normally!\n");
+                break;
+        case GDB_STATE_STOPPED:
+                //categorize bug
+                if ((strcasecmp(cntxt->gdb_stop_reason->signal_meaning, "Segmentation fault") == 0)
+                 || (strcasecmp(cntxt->gdb_stop_reason->signal_meaning, "Signal 0") == 0))
+                        cntxt->bug_detected = MONKEY_ACTION_is_Nullpointer(cntxt) ? BUG_NULL_POINTER : BUG_BAD_MEM_ACCESS;
+                else if (strcasecmp(cntxt->gdb_stop_reason->signal_meaning, "Aborted") == 0)
+                        cntxt->bug_detected = BUG_ABORT;
+                else if (strcasecmp(cntxt->gdb_stop_reason->signal_meaning, "Arithmetic exception") == 0)
+                        cntxt->bug_detected = BUG_ARITHMETIC;
+                else if (strcasecmp(cntxt->gdb_stop_reason->signal_name, "SIGBUS") == 0)
+                        cntxt->bug_detected = BUG_SIG_BUS;
+
+                // get relevant expressions
+                retVal = MONKEY_ACTION_inspect_expression_database (cntxt);
+
+                if (MONKEY_NO == retVal)
+                {
+                        fprintf( stderr,
+                        "Error in using the expression database. Pathologist will exit now!\n");
+                        ret = 1;
+                        break;
+                }
+                else if (BUG_BAD_MEM_ACCESS == cntxt->bug_detected
+                || BUG_SIG_BUS == cntxt->bug_detected)
+                {
+                        /* launch valgrind */
+                        retVal = MONKEY_ACTION_rerun_with_valgrind (cntxt);
+                        if (MONKEY_NO == retVal)
+                                fprintf( stderr, "Error using Valgrind! Pathologist will continue debugging!\n");
+                }
+
+                /* Start backtracking if enabled by user */
+                if (cntxt->run_reverse) {
+                        retVal = MONKEY_ACTION_start_reverse_execution(cntxt);
+                        if (MONKEY_NO == retVal)
+                                fprintf(stderr, "Error during Backtracking! Pathologist will continue debugging with backtracking.\n");
+                }
+
+
+                //                              REPORTING
+                if (MONKEY_OK != MONKEY_ACTION_format_report_xml (cntxt))
+                {
+                        fprintf( stderr,
+                        "Error in generating debug report!\n");
+                        ret = 1;
+                }
+                if (emailAddress != NULL)
+                {
+                        if (MONKEY_OK != MONKEY_ACTION_report_email (cntxt, dumpFileName))
+                        {
+                                fprintf( stderr, "Error sending email!\n");
+                                ret = 1;
+                        }
+                }
+                if (dumpFileName != NULL)
+                {
+                        if (MONKEY_OK !=
+                        MONKEY_ACTION_report_file (cntxt, dumpFileName, MONKEY_YES))
+                        {
+                                fprintf( stderr,
+                                "Error in saving debug file!\n");
+                                ret = 1;
+                        }
+                }
+                break;
+        default:
+                break;
+        }
+
+MONKEY_ACTION_delete_context (cntxt);
+}
+
+
+int freePathologistArgs()
+{
+        if (NULL != dumpFileName)
+                MONKEY_free(dumpFileName);
+        if (NULL != emailAddress)
+                MONKEY_free(emailAddress);
+        if (NULL != edbFilePath)
+                MONKEY_free(edbFilePath);
+        if (NULL != gdbBinaryPath)
+                MONKEY_free(gdbBinaryPath);
+        if (NULL != valgrindBinaryPath)
+                MONKEY_free(valgrindBinaryPath);
+        if (NULL != inspectExpression)
+                MONKEY_free(inspectExpression);
+        if (NULL != inspectFunction)
+                MONKEY_free(inspectFunction);
+
+        return MONKEY_OK;
+}
+
+
+
+const char * buildBinaryArgs(int argc, char **argv) {
+        char * res = MONKEY_strdup("");
+        char * tmp;
+        int i;
+        for (i = 0; i < argc; i++) {
+                MONKEY_asprintf(&tmp, "%s %s", res, argv[i]);
+                MONKEY_free(res);
+                res = tmp;
+        }
+
+        return res;
+}
+
+int
+main (int argc, char *argv[])
+{
+        static const struct MONKEY_GETOPT_CommandLineOption options[] = {
+                {'d', "database", "FILENAME", "the expression database to use, generated by seaspider",
+                        1, &MONKEY_GETOPT_set_string, &edbFilePath},
+                {'f', "function", "FUNCTIONNAME", "the name of the function, in which pathologist will set a breakpoint",
+                        1, &MONKEY_GETOPT_set_string, &inspectFunction},
+                {'g', "gdb", "FILENAME", "path to gdb binary to use. If not passed, pathologist will set it to /usr/bin/gdb",
+                        1, &MONKEY_GETOPT_set_string, &gdbBinaryPath},
+                {'h', "help", NULL, "shows this help",
+                        0, &MONKEY_GETOPT_format_help_, "Monkey Pathologist: Automatically debug a service"},
+                {'i', "inspect", "EXPRESSIONNAME", "expression to inspect in the function specified after argument f",
+                        1, &MONKEY_GETOPT_set_string, &inspectExpression},
+                {'l', "valgrind", "FILENAME", "path to valgrind binary. If not passed, pathologist will set it to /usr/bin/valgrind",
+                        1, &MONKEY_GETOPT_set_string, &valgrindBinaryPath},
+                {'m', "mail", "MAILADDRESS", "if specified, pathologist will send the bugreport to the given address",
+                        1, &MONKEY_GETOPT_set_string, &emailAddress},
+                {'o', "report", "FILENAME", "saves the xml formated report to the given file",
+                        1, &MONKEY_GETOPT_set_string, &dumpFileName},
+                {'p', "depth", "UINT", "scope depth. How many scopes should pathologist lookup expression values outer than the scope in which the problem occurs. Default is 0 which means, pathologist is restricted to the scope of the expression in which the debugged program stopped" ,
+                        1, &MONKEY_GETOPT_set_uint, &scopeDepth},
+                {'r', "reverse", NULL, "enables reverse execution",
+                        0, &MONKEY_GETOPT_set_one, &reverseExecutionAllowed},
+                {'v', "version", NULL, "print the version number",
+                        0, &MONKEY_GETOPT_print_version_, "0.1 alpha"},
+                MONKEY_GETOPT_OPTION_END
+        };
+
+        if (-1 == (ret = MONKEY_GETOPT_run ("pathologist -d DATABASEFILE [options] [--] BINARY", options, (unsigned int) argc, argv)))
+                return -1;
+
+        // Check for required arguments
+        if (argc <= ret)
+                printf("Error: missing argument: path to the binary file.\n");
+        if (NULL == edbFilePath)
+                printf("Error: missing argument: path to expression database file.\n");
+        if (argc <= ret || NULL == edbFilePath)
+                exit(EXIT_FAILURE);
+
+        /* All remaining args are considered program arguments */
+        binaryName = argv[ret];
+        command    = (char *)buildBinaryArgs(argc - ret, &argv[ret]) + 1;
+        binaryArgs = (char *)buildBinaryArgs(argc - ret - 1, &argv[ret + 1]);
+
+        printf("\n%s\n%s\n%s\n\n", binaryName, command, binaryArgs);
+        
+        /* Run Pathologist */
+        run();
+
+        /* clean up */
+        freePathologistArgs();
+
+        return ret;
+}