/*
 * See the dyninst/COPYRIGHT file for copyright information.
 * 
 * We provide the Paradyn Tools (below described as "Paradyn")
 * on an AS IS basis, and do not warrant its validity or performance.
 * We reserve the right to update, modify, or discontinue this
 * software at any time.  We shall have no obligation to supply such
 * updates or modifications or any other form of support to you.
 * 
 * By your use of Paradyn, you understand and agree that we (or any
 * other person or entity with proprietary rights in Paradyn) are
 * under no obligation to provide either maintenance services,
 * update services, notices of latent defects, or correction of
 * defects for Paradyn.
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * 
 * This library 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
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
#ifndef __CONFIG_H__
#define __CONFIG_H__

#include <iostream>
#include <set>
#include <deque>
#include <string>
#include <unistd.h>
#include <limits.h>		// Needed for PATH_MAX.

using namespace std;

#include "record.h"
#include "reglist.h"
#include "dyninstCompat.h"

#define STRING_MAX 1024

#define HISTORY_RECORD_DIR_DEFAULT ".parseThat"
#define HISTORY_RECORD_INDEX_FILE ".history_index"
#define DEFAULT_HUNT_FILE "hunt_parseThat"

enum RunMode {
    SINGLE_BINARY,
    BATCH_DIRECTORY,
    BATCH_FILE
};

enum TransactionMode {
    TRANS_NONE,
    TRANS_FUNCTION,
    TRANS_MODULE,
    TRANS_PROCESS
};

enum ParseLevel {
    PARSE_MODULE,
    PARSE_FUNC,
    PARSE_CFG,
    PARSE_MAX
};

enum InstLevel {
    INST_NONE,
    INST_FUNC_ENTRY,
    INST_FUNC_EXIT,
    INST_BASIC_BLOCK,
    INST_MEMORY_READ,
    INST_MEMORY_WRITE,
    INST_MAX
};

enum InstType {
    USER_FUNC,
    DEFAULT 
};

enum RunState {
    NORMAL,
    SIGCHLD_WAIT,
    TIME_EXPIRED,
    CHILD_EXITED,
    DETACHED
};

struct Config {
    RunMode runMode;
    TransactionMode transMode;

    // Holds the next target to open.  Generally set by getNextTarget().
    char target[ PATH_MAX ];
    char **argv;
    unsigned argc;

    // For BATCH_FILE runMode.
    const char *config_file;

    // For instrumenting with functions loaded from library
    // format library:function_name
    const char *inst_function;
    InstType instType;

    // Output file string and descriptor.
    const char *output_file;
    FILE *outfd;

    // String to hold the list of arguments for executing rewritten binary
    // in runHunt mode
    char *binary_args;

    // History record directory.
    bool record_enabled;
    char record_dir[ PATH_MAX ];
    record_t curr_rec;

    bool no_fork; // For IPC debugging.  See if we should run without monitor.
    bool recursive; // Descend into children when processing directories.
    bool summary; // Print instrumemnation summary on mutatee exit.
    bool memcpu; // Print memory and CPU usage on mutatee exit.
    bool include_libs; // Process shared libraries as well as program modules.
    bool use_attach; // Attach to running process instead of forking new one.
    int  attach_pid;
    bool use_merge_tramp; // Use merge tramp for instrumentation.
  
    bool use_exe; // Use seperate execitable file instead of the rewritten
                  // library. Used for executing rewritten shared libraries
    bool use_process; // Standard in-core instrumentation or binary edit
    bool write_crashes; // Rewrite with given limits
    bool hunt_crashes; // Keep running until crash is found
    bool hunt_crashed; // True if process crashed
    int hunt_low;
    int hunt_high;
    FILE *hunt_file;

    char writeFilePath[PATH_MAX];
    char exeFilePath[PATH_MAX];

    char *saved_mutatee;

    bool trace_inst;      // Trace mutatee as it is running.
    unsigned int trace_count;
    deque< string > trace_history;
    char pipe_filename[ PATH_MAX ];
    int pipefd;

    // Child PID accounting.
    int pid;
    set< int > grandchildren;

    // Debug print level.
    int verbose;
    bool printipc;

    // Dyninst test level.
    ParseLevel parse_level;
    InstLevel inst_level;

    // Time limit for child execution.
    int time_limit;

    // Reflects current state of execution.
    RunState state;

    // True if parseThat/mutatee exited abnormally
    bool abnormal_exit;

    // Mutators register their dBPatch_thread object here for
    // efficient process clean-up in the face of signals.
    dynHandle *dynlib;

    // Rules for which modules/functions to process.
    reglist mod_rules;
    reglist func_rules;

    // Collection of libraries used for symbols when rewriting 
    // a static binary
    deque<string> symbol_libraries;

    BPatch_remoteHost *remoteHost;
};

extern Config config;

void configInit();
bool getNextTarget();

#endif