main.cc

Go to the documentation of this file.

#include <iostream>
#include <string.h>
#include "include/generic.h"
#include "include/plugins/Plugin.h"
#include "include/plugins/AsteriskPlugin.h"
#include "include/Debug.h"
#include "include/Configuration.h"
#include "include/Cli.h"
#include "include/NetSniff.h"

#include <boost/bind.hpp>
#include <boost/thread/thread.hpp>

using namespace std;
using namespace plugins;
using namespace network;
using namespace boost;
using namespace debug;

int main(int argc, const char* argv[]) {

        string confFile;
        Debug dbg;
        
        bool debug, debugcode;

        if (argc < 2)
        {
                ostringstream err;
                
                cout << "ERROR: You need to specify main config file path" << endl;
                cout << "Usage: " << argv[0];
                cout << " -conf main.conf" << endl;
                return -1;
        }
        else
        {
                cout << "Starting VoipHoney version " << VOIPHONEY_VER << endl;
                // Parse command line parameters
                for (int i=1; i < argc; i++)
                {
                        if (strcmp(argv[i], "-conf") == 0)
                                confFile = argv[++i];
                }

                // Specify valid sections and vars
                const char* s[] = {"global", "plugins", "paths", "help"};
                const char* v[] = {"background", "debug", "use_sip", "use_plugins",
                        "asterisk_plugin", "asterisk_conf_path", "verbosity", "sniff_sip",
                        "sniff_device", "show_sniff", "capture_sniff", "capture_path",
                        "helpcmdpath", "debugcode"};
                vector<string> sections(s, s + sizeof(s) / sizeof(const char*));
                vector<string> vars(v, v + sizeof(v) / sizeof(const char*));
                
                // Load Configuration
                Configuration conf(confFile, &dbg, sections, vars);
                
                // Setup debugger
                if (conf.GetValue("debug") == "yes")
                        debug = true;
                else
                        debug = false;

                if (conf.GetValue("debugcode") == "yes")
                        debugcode = true;
                else
                        debugcode = false;      

                dbg.SetDebug(debug, debugcode);
                dbg.SetVerbosity(conf.GetValue("verbosity"));
                dbg.Prntdbg(CODEAT, 0, "Verbosity is now " + dbg.GetVerbosity());
                dbg.Prntdbg(CODEAT, 10, "Configuration Loaded ...");
                conf.LoadSysVars();
                
                
                // Check if sniffing is needed
                // Sniff for SIP
                string port = "5060";
                string sniffproto = "udp";
                NetSniff net(conf.GetValue("sniff_device"), port, sniffproto);
                
                // Setup debugger for the sniffer
                net.setDebugger(&dbg);
                
                // Setup the sniffer
                if (conf.GetValue("sniff_sip").compare("yes") == 0)
                {
                        dbg.Prntdbg(CODEAT, 10, "Starting sniff process for " +
                                                conf.GetValue("sniff_device") + " device ..."
                        );
                        
                        if (net.Open())
                        {
                                if (net.ApplyFilter("default"))
                                {
                                        // Setup all sniffing option
                                        if (conf.GetValue("show_sniff").compare("yes") == 0)
                                                net.SetShow(true);
                                        else
                                                net.SetShow(false);
                                        
                                        if (conf.GetValue("capture_sniff").compare("yes") == 0)
                                                net.SetCapture(true, conf.GetValue("capture_path"));
                                        else
                                                net.SetCapture(false, conf.GetValue("capture_path"));
                                        
                                        // Start sniffing in a new thread
                                        thread* sniffThread = new thread(bind(&network::NetSniff::startsniff,&net));
                                        if (sniffThread == NULL)
                                                dbg.Prnterr(CODEAT, "Error creating thread");
                                }
                        }
                        else
                                dbg.Prntdbg(CODEAT, 50, "Device open NOT possible. Check user permissions and sniff_device");
                }
                
                // Check if plugins are disabled
                if (conf.GetValue("use_plugins").compare("yes") == 0)
                {
                        
                        if (conf.GetValue("asterisk_plugin").compare("yes") == 0)
                        {
                                AsteriskPlugin ast;
                                ast.SetDebugger(&dbg);
                                ast.SetActive(true);
                                ast.LoadConf(conf.GetValue("asterisk_conf_path"));
                        }
                }
                
                // If not running on background load cli
                if (conf.GetValue("background").compare("no") == 0)
                {
                        Cli cli(conf, &net);
                        if (cli.SetDebugger(&dbg))
                                cli.MainLoop();
                }               
        }
        
        
        
        cout << "Finished ..." << endl;
        dbg.Prntdbg(CODEAT, 50, "Exit and return 0");
        
    return 0;

}

---