source: trunk/src/arm4_control.cpp @ 704

/**********************************************************************
 * Copyright (c) 2005-2008 David Carter <dcarter@arm4.org> and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors: 
 * David Carter - Initial API and implementation
 **********************************************************************/

#include "config.h"
 
#include <sys/types.h>
#include <sys/time.h>
#include <errno.h>
#include <signal.h>

#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>

#ifdef HAVE_GETOPT_H
#include <getopt.h>
#endif

#include <db.h>
#include "arm4.h"
#include "arm4agent.h"
#include "Arm4db.h"
#include "Logger.h"
#include "Arm4dbDaemonSharedMemory.h"

/* Prototypes */
static void usage (void);

static void
print_trace_flags (arm4_shm_transaction_trace_t flags)
{
        if (flags & arm4_shm_transaction_trace_all)
                printf (" all");
        else if (flags & arm4_shm_transaction_trace_n)
                printf (" sample");
        else if (flags & arm4_shm_transaction_trace_interval)
                printf (" interval");
        if (flags & arm4_shm_transaction_trace_use_default)
                printf (" default");
        if (flags & arm4_shm_transaction_trace_honor_request)
                printf (" application");
}

static void
print_appdex_flags (arm4_appdex_t flags)
{
        if (flags & arm4_appdex_on)
                printf (" on");
        else
                printf (" off");
        
        if (flags & arm4_appdex_use_default)
                printf (" default");
        if (flags & arm4_appdex_autolearn)
                printf (" autolearn");
}

static void
print_id (const arm_id_t &id)
{
        for (int i  = 0; i < 16; i++)
                printf ("%02x", id.id_u.uint8 [i]);
}

static arm_error_t
get_id (arm_id_t &id, const char *string_ptr)
{
        if (strlen (string_ptr) != 32)
                return ARM_FAILURE;

        int hex_value = 0;
        for (int i = 0; i < 16; i++)
        {
                int size = sscanf (&(string_ptr [i*2]), "%02x", &hex_value);
                id.id_u.uint8 [i] = (hex_value & 0x0FF);
                if (size != 1)
                {
                        return ARM_FAILURE;
                }
        }
        return ARM_SUCCESS;
}

static void
help_archive (void)
{
        printf ("archive - archive the current database\n");
}

static void
command_archive (int argc, char *argv[], int optind)
{
        /* No parameters to archive */
        if (argc != 1)
        {
                help_archive ();
                exit (0);
        }

        Arm4dbDaemonSharedMemory::utilityCommand (ARM4_SHM_COMMAND_BACKUP);
}

static void
help_collect (void)
{
        printf ("collect - show current collection state\n");
        printf ("collect status - show current collection state\n");
        printf ("collect yes - turn collection on\n");
        printf ("collect on - turn collection on\n");
        printf ("collect no - turn collection off\n");
        printf ("collect off - turn collection off\n");
}

static void
command_collect (int argc, char *argv[], int optind)
{
        if ((argc < 1) || (argc > 2))
        {
                help_collect ();
                exit (0);
        }

        Arm4dbDaemonSharedMemory shm;
        if ((argc == 1) ||
                (strcasecmp (argv [optind + 1], "status") == 0))
        {
                /* do nothing until the end */;
        }
        else if (
                (strcasecmp (argv [optind + 1], "yes") == 0) ||
                (strcasecmp (argv [optind + 1], "on") == 0))
        {
                shm.setNullCollector (ARM_FALSE);
        }
        else if (
                (strcasecmp (argv [optind + 1], "no") == 0) ||
                (strcasecmp (argv [optind + 1], "off") == 0))
        {
                shm.setNullCollector (ARM_TRUE);
        }
        else
        {
                help_collect ();
                exit (0);
        }

    if (shm.getNullCollector ())
        printf ("Collection is OFF\n");
    else
        printf ("Collection is ON\n");
}

static void
help_checkpoint (void)
{
        printf ("collect - perform an immediate database checkpoint operation\n");
}

static void
command_checkpoint (int argc, char *argv[], int optind)
{
        if (argc != 1)
        {
                help_checkpoint ();
                exit (0);
        }

        Arm4dbDaemonSharedMemory::utilityCommand (ARM4_SHM_COMMAND_CHECKPOINT);
}

static void
help_status (void)
{
        printf ("status - show the arm4_daemon status\n");
}

static void
command_status (int argc, char *argv[], int optind)
{
        pid_t daemon_pid;

        /* No parameters to stop */
        if (argc != 1)
        {
                help_status ();
                exit (0);
        }

        /* Stop the daemon */
        daemon_pid = Arm4dbDaemonSharedMemory::getActiveDaemon ();
        if (daemon_pid != (pid_t) 0)
        printf ("arm4_daemon is alive\n");
    else
        printf ("No arm4_daemon process is running\n");
}

static void
help_stop (void)
{
        printf ("stop - stop the current arm4_daemon instance\n");
}

static void
command_stop (int argc, char *argv[], int optind)
{
        pid_t daemon_pid;

        /* No parameters to stop */
        if (argc != 1)
        {
                help_stop ();
                exit (0);
        }

        /* Stop the daemon */
        daemon_pid = Arm4dbDaemonSharedMemory::getActiveDaemon ();
        if (daemon_pid != (pid_t) 0)
                kill (daemon_pid, SIGTERM);
}

static void
help_remove (void)
{
        printf ("remove - remove shared memory regions and semaphores\n");
}

static void
command_remove (int argc, char *argv[], int optind)
{
        /* No parameters to command_remove */
        if (argc != 1)
        {
                help_remove ();
                exit (0);
        }

        /* Check if a daemon is running */
    if (Arm4dbDaemonSharedMemory::getActiveDaemon () != (pid_t) 0)
    {
        fprintf (stderr, "arm4_daemon is running. Please stop the daemon first.\n");
        exit (1);
    }

    /* Remove the shared memory */
        Arm4dbDaemonSharedMemory::shmDestroy ();
}

static void
help_wipe (void)
{
    printf ("wipe - remove the current database, shared memory regions, and semaphores\n");
}

static void
command_wipe (int argc, char *argv[], int optind)
{
        /* No parameters to command_wipe */
        if (argc != 1)
        {
                help_wipe ();
                exit (0);
        }

        /* Check if a daemon is running */
    if (Arm4dbDaemonSharedMemory::getActiveDaemon () != (pid_t) 0)
    {
        fprintf (stderr, "arm4_daemon is running. Please stop the daemon first.\n");
        exit (1);
    }

    /* Remove the shared memory */
        Arm4dbDaemonSharedMemory::shmDestroy ();

    /* Remove the databases */
        Arm4db::getArm4db ()->removeDatabases ();
}

static void
help_application (void)
{
    printf ("\tapplication - displays the current application definitions\n");
    printf ("\tapplication {app_id} - displays the configuration for a specific application id\n");
    printf ("\tapplication {app_id} transactions - displays the transactions associated a specific application id\n");
}

static void
display_app_definitions (void)
{
        // iterate through the list of application definitions
        std::list<arm_id_t> *app_lptr = Arm4db::getArm4db ()->getApplicationList ();

        if (app_lptr->empty ())
        {
                printf ("No applications found\n");
                delete app_lptr;
                return;
        }

        std::list<arm_id_t>::iterator current = app_lptr->begin();
        arm4db_application_summary_t summary;
        while (current != app_lptr->end())
        {
                Arm4db::getArm4db ()->getApplicationInformation (*current, &summary);

                // print the information
                printf ("Application: %s\n", summary.application_name);
                printf ("  ID: ");
                print_id (summary.appl_id);
                printf ("\n");
                printf ("  Character set: %d\n", summary.charset);
                printf ("\n");
                
                current++;
        }
        
        delete app_lptr;
}

static void
display_app_config (const arm_id_t &app_id)
{
        arm4db_application_summary_t summary;

        Arm4db::getArm4db ()->getApplicationInformation (app_id, &summary);

        // print the information
        printf ("Application: %s\n", summary.application_name);
        printf ("  Default transaction flags:");
        print_trace_flags (summary.default_trace_flags);
        printf ("\n");
        printf ("  Default transaction parameter: %lld\n", summary.default_trace_parameter);
        printf ("  Default appdex threshold: %lld\n", summary.default_appdex_threshold);
        printf ("\n");
}

static void
display_app_transactions (const arm_id_t &app_id)
{
        // iterate through the list of application definitions
        std::list<arm_id_t> *tran_lptr = Arm4db::getArm4db ()->getTransactionList (app_id);

        if (tran_lptr->empty ())
        {
                printf ("No transactions found\n");
                delete tran_lptr;
                return;
        }

        std::list<arm_id_t>::iterator current = tran_lptr->begin();
        arm4db_transaction_summary_t summary;
        while (current != tran_lptr->end())
        {
                Arm4db::getArm4db ()->getTransactionInformation (*current, &summary);

                // print the information
                printf ("Transaction: %s\n", summary.transaction_name);
                printf ("  Transaction ID: ");
                print_id (summary.tran_id);
                printf ("\n");
                printf ("  Application ID: ");
                print_id (summary.appl_id);
                printf ("\n");
                printf ("  URI: %s\n", summary.uri);
                printf ("\n");
                
                current++;
        }
        
        delete tran_lptr;
}

static void
command_application (int argc, char *argv[], int optind)
{
        /* No parameters to command_wipe */
        if ((argc < 1) || (argc > 3))
        {
                help_application ();
                exit (0);
        }

        /* Check if a daemon is running */
        Arm4dbDaemonSharedMemory::shmAttach ();
        
        if (argc == 1)
        {
                display_app_definitions ();
        }
        else
        {
                /* Get the application id, and see if there's anything after that */
                arm_id_t app_id;

                if (get_id (app_id, argv [optind + 1]) != ARM_SUCCESS)
                        printf ("Invalid id %s\n", argv [optind + 1]);
                else if (argc == 2)
                {
                        display_app_config (app_id);
                }
                else if (strcasecmp (argv [optind + 2], "transactions") == 0)
                {
                        display_app_transactions (app_id);
                }
                else
                {
                        help_application ();
                }
        }

}

static void
help_transaction (void)
{
    printf ("\ttransaction - displays the current transaction definitions\n");
    printf ("\ttransaction {tran_id} - displays the configuration for a specific transaction id\n");
    printf ("\ttransaction {tran_id} trace all - trace all transaction instances\n");
    printf ("\ttransaction {tran_id} trace none - turn tracing off\n");
    printf ("\ttransaction {tran_id} trace {n} - trace every nth transaction instance\n");
    printf ("\ttransaction {tran_id} trace {n}[s|S] - trace one transaction instance every n tenths of seconds\n");
    printf ("\ttransaction {tran_id} trace application - honor application trace requests\n");
    printf ("\ttransaction {tran_id} trace noapplication - ignore application trace requests\n");
    printf ("\ttransaction {tran_id} trace default - use application default settings\n");
}

static void
display_tran_definitions (void)
{
        // iterate through the list of transaction definitions
        std::list<arm_id_t> *tran_lptr = Arm4db::getArm4db ()->getTransactionList ();

        if (tran_lptr->empty ())
        {
                printf ("No transactions found\n");
                delete tran_lptr;
                return;
        }

        std::list<arm_id_t>::iterator current = tran_lptr->begin();
        arm4db_transaction_summary_t summary;
        while (current != tran_lptr->end())
        {
                Arm4db::getArm4db ()->getTransactionInformation (*current, &summary);

                // print the information
                printf ("Transaction: %s\n", summary.transaction_name);
                printf ("  Transaction ID: ");
                print_id (summary.tran_id);
                printf ("\n");
                printf ("  Application ID: ");
                print_id (summary.appl_id);
                printf ("\n");
                printf ("  URI: %s\n", summary.uri);
                printf ("\n");
                
                current++;
        }
        
        delete tran_lptr;
}

static void
display_tran_config (const arm_id_t &tran_id)
{
        arm4db_transaction_summary_t summary;

        if (Arm4db::getArm4db ()->getTransactionInformation (tran_id, &summary) != 0)
        {
                printf ("Unable to obtain transaction information\n");
                exit (0);
        }

        // print the information
        printf ("Transaction: %s\n", summary.transaction_name);
        printf ("  Transaction flags:");
        print_trace_flags (summary.trace_flags);
        printf ("\n");
        printf ("  Transaction parameter: %lld\n", summary.trace_parameter);
        printf ("  Appdex flags:");
        print_appdex_flags (summary.appdex_flags);
        printf ("\n");
        printf ("  Appdex threshold: %lld\n", summary.appdex_threshold);
        printf ("\n");
}

static void
config_trace (const arm_id_t &tran_id, const char *arg_ptr)
{
        arm4db_transaction_summary_t summary;

        if (Arm4db::getArm4db ()->getTransactionInformation (tran_id, &summary) != 0)
        {
                printf ("Unable to obtain transaction information\n");
                exit (0);
        }

    if (strcasecmp (arg_ptr, "all") == 0)
        {
        int flags = (int) summary.trace_flags;
        flags &= ~(arm4_shm_transaction_trace_n | arm4_shm_transaction_trace_interval | arm4_shm_transaction_trace_use_default);
        flags |= arm4_shm_transaction_trace_all;
        summary.trace_flags = (arm4_shm_transaction_trace_t) flags;
        summary.trace_parameter = 0;
        }
        else if (strcasecmp (arg_ptr, "none") == 0)
        {
        int flags = (int) summary.trace_flags;
        flags &= ~(arm4_shm_transaction_trace_all | arm4_shm_transaction_trace_n | arm4_shm_transaction_trace_interval | arm4_shm_transaction_trace_use_default);
        summary.trace_flags = (arm4_shm_transaction_trace_t) flags;
        summary.trace_parameter = 0;
        }
        else if (strcasecmp (arg_ptr, "application") == 0)
        {
        int flags = (int) summary.trace_flags;
        flags |= arm4_shm_transaction_trace_honor_request;
        summary.trace_flags = (arm4_shm_transaction_trace_t) flags;
        }
        else if (strcasecmp (arg_ptr, "noapplication") == 0)
        {
        int flags = (int) summary.trace_flags;
        flags &= ~(arm4_shm_transaction_trace_honor_request);
        summary.trace_flags = (arm4_shm_transaction_trace_t) flags;
        }
        else if (strcasecmp (arg_ptr, "default") == 0)
        {
        int flags = (int) summary.trace_flags;
        flags &= ~(arm4_shm_transaction_trace_all | arm4_shm_transaction_trace_n | arm4_shm_transaction_trace_interval);
        flags |= arm4_shm_transaction_trace_use_default;
        summary.trace_flags = (arm4_shm_transaction_trace_t) flags;
        summary.trace_parameter = 0;
        }
        else
        {
                arm_int64_t trace_parameter;
                char seconds;
                
                int count = sscanf (arg_ptr, "%lld%c", &trace_parameter, &seconds);
                if (count == 1)
                {
                        // Sample count
                int flags = (int) summary.trace_flags;
                flags &= ~(arm4_shm_transaction_trace_all | arm4_shm_transaction_trace_interval | arm4_shm_transaction_trace_use_default);
                flags |= arm4_shm_transaction_trace_n;
                summary.trace_flags = (arm4_shm_transaction_trace_t) flags;
                summary.trace_parameter = trace_parameter;
                }
                else if ((count == 2) && (toupper(seconds) == 'S'))
                {
                        // Interval seconds
                int flags = (int) summary.trace_flags;
                flags &= ~(arm4_shm_transaction_trace_all | arm4_shm_transaction_trace_n | arm4_shm_transaction_trace_use_default);
                flags |= arm4_shm_transaction_trace_interval;
                summary.trace_flags = (arm4_shm_transaction_trace_t) flags;
                summary.trace_parameter = trace_parameter;
                }
                else
                {
                        help_transaction ();
                        exit (0);
                }
        }

    // Store the changed configuration
    Arm4db::getArm4db ()->setTransactionTraceInformation (tran_id, summary);

        Arm4dbDaemonSharedMemory shm;
    shm.setTransactionTraceInformation (tran_id, summary);
    
    // Display the updated information
    display_tran_config (tran_id);
}

static void
command_transaction (int argc, char *argv[], int optind)
{
        /* No parameters to command_wipe */
        if ((argc < 1) || (argc > 4))
        {
                help_transaction ();
                exit (0);
        }

        /* Check if a daemon is running */
        Arm4dbDaemonSharedMemory::shmAttach ();
        
        if (argc == 1)
        {
                display_tran_definitions ();
        }
        else
        {
                /* Get the application id, and see if there's anything after that */
                arm_id_t tran_id;

                if (get_id (tran_id, argv [optind + 1]) != ARM_SUCCESS)
                        printf ("Invalid id %s\n", argv [optind + 1]);
                else if (argc == 2)
                {
                        display_tran_config (tran_id);
                }
                else if ((argc == 4) && (strcasecmp (argv [optind + 2], "trace") == 0))
                {
                        config_trace (tran_id, argv [optind + 3]);
                }
                else
                {
                        help_transaction ();
                        exit (0);
                }
        }

}

static void
help_export (void)
{
    printf ("\texport definitions - exports application, metric, and transaction definitions to stdout\n");
    printf ("\texport all - exports definitions and instance data to stdout\n");
}

static void
export_definitions (void)
{
        Arm4dbUtilityLock lock;

        Arm4db *arm4db_ptr = Arm4db::getArm4db ();
        arm_error_t status = arm4db_ptr->openDatabases ();
        if (status != ARM_SUCCESS)
        {
                lock.unlock ();
                exit (0);
        }

    arm4db_ptr->exportDefinitions (std::cout);
                
        arm4db_ptr->closeDatabases ();

        lock.unlock ();
}

static void
export_all (void)
{
        Arm4dbUtilityLock lock;

        Arm4db *arm4db_ptr = Arm4db::getArm4db ();
        arm_error_t status = arm4db_ptr->openDatabases ();
        if (status != ARM_SUCCESS)
        {
                lock.unlock ();
                exit (0);
        }

    arm4db_ptr->exportAll (std::cout);
                
        arm4db_ptr->closeDatabases ();

        lock.unlock ();
}

static void
command_export (int argc, char *argv[], int optind)
{
        /* No parameters to command_wipe */
        if (argc != 2)
        {
                help_export ();
                exit (0);
        }

        /* Check if a daemon is running */
        Arm4dbDaemonSharedMemory::shmAttach ();

        if (strcasecmp(argv[optind + 1],"definitions") == 0)
        {
                export_definitions ();
        }
        else if (strcasecmp(argv[optind + 1],"all") == 0)
        {
                export_all ();
        }
        else
        {
                help_export ();
                exit (0);
        }
}


static void
help_import (void)
{
    printf ("\timport filename - imports an exported database from the file\n");
}

static void
import_xml (const char *filename_ptr)
{
        Arm4dbUtilityLock lock;

        Arm4db *arm4db_ptr = Arm4db::getArm4db ();
        arm_error_t status = arm4db_ptr->openDatabases ();
        if (status != ARM_SUCCESS)
        {
                lock.unlock ();
                exit (0);
        }

    arm4db_ptr->import (filename_ptr);
                
        arm4db_ptr->closeDatabases ();

        lock.unlock ();
}

static void
command_import (int argc, char *argv[], int optind)
{
        /* No parameters to command_wipe */
        if (argc != 2)
        {
                help_import ();
                exit (0);
        }

        /* Check if a daemon is running */
        Arm4dbDaemonSharedMemory::shmAttach ();
        
        // Check that we have access to the file
        
        import_xml (argv[optind + 1]);
}

static void
help_debug (void)
{
    printf ("\tdebug level - Set the debug level. Higher is more information, 0 is off\n");
}

static void
command_debug (int argc, char *argv[], int optind)
{
        /* No parameters to command_wipe */
        if (argc != 2)
        {
                help_export ();
                exit (0);
        }

        /* Check if a daemon is running */
        Arm4dbDaemonSharedMemory::shmAttach ();
        
        Arm4dbUtilityLock lock;

        int level = std::atoi (argv[optind + 1]);
        Arm4dbSharedMemory::setDebugLevel (level);

        lock.unlock ();
}

static void
help_commands (void)
{
        printf ("Valid commands:\n");
        printf ("\tarchive - archive the current database\n");
        printf ("\tcollect - turn collection on or off\n");
        printf ("\tcheckpoint - perform a database chckpoint operation\n");
        printf ("\tremove - remove shared memory regions and semaphores\n");
    printf ("\tstatus - show the arm4_daemon status\n");
        printf ("\tstop - stop the current arm4_daemon instance\n");
        printf ("\twipe - remove the current database, shared memory regions, and semaphores\n");
        printf ("\tapplication - display and configure application definitions\n");
        printf ("\ttransaction - display and configure transaction definitions\n");
        printf ("\texport - export database to xml\n");
        printf ("\timport - import database from xml\n");
        printf ("\tdebug - set debugging level\n");
        printf ("\tcommands - show valid commands\n");
        printf ("\nType help <command> for information on that command\n");
}

static void
command_help (int argc, char *argv[], int optind)
{
        /* No parameters to archive */
        if (argc > 2)
        {
                usage ();
                exit (0);
        }

        if ((argc == 1) || (strcasecmp (argv [optind + 1], "commands") == 0))
        {
                help_commands ();
        }
        else if (strcasecmp (argv [2], "archive") == 0)
        {
                help_archive ();
        }
        else if (strcasecmp (argv [2], "collect") == 0)
        {
                help_collect ();
        }
        else if (strcasecmp (argv [2], "checkpoint") == 0)
        {
                help_checkpoint ();
        }
        else if (strcasecmp (argv[2], "remove") == 0)
        {
                help_remove ();
        }
    else if (strcasecmp (argv[2], "status") == 0)
    {
        help_status ();
    }
    else if (strcasecmp (argv[2], "stop") == 0)
    {
        help_stop ();
    }
        else if (strcasecmp (argv[2], "wipe") == 0)
        {
                help_wipe ();
        }
        else if (strcasecmp (argv[2], "application") == 0)
        {
                help_application ();
        }
        else if (strcasecmp (argv[2], "transaction") == 0)
        {
                help_transaction ();
        }
        else if (strcasecmp (argv[2], "export") == 0)
        {
                help_export ();
        }
        else if (strcasecmp (argv[2], "import") == 0)
        {
                help_import ();
        }
        else if (strcasecmp (argv[2], "debug") == 0)
        {
                help_debug ();
        }
        else
        {
                fprintf (stderr, "Unrecognized command %s\n", argv[1]);
                help_commands ();
        }

}

static void
process_command (int argc, char *argv[], int optind)
{
        if (strcasecmp (argv [optind], "archive") == 0)
        {
                command_archive (argc, argv, optind);
        }
        else if (strcasecmp (argv[optind], "collect") == 0)
        {
                command_collect (argc, argv, optind);
        }
        else if (strcasecmp (argv[optind], "checkpoint") == 0)
        {
                command_checkpoint (argc, argv, optind);
        }
    else if (strcasecmp (argv[optind], "remove") == 0)
    {
        command_remove (argc, argv, optind);
    }
        else if (strcasecmp (argv[optind], "status") == 0)
        {
                command_status (argc, argv, optind);
        }
    else if (strcasecmp (argv[optind], "stop") == 0)
    {
        command_stop (argc, argv, optind);
    }
    else if (strcasecmp (argv[optind], "wipe") == 0)
    {
        command_wipe (argc, argv, optind);
    }
    else if (strcasecmp (argv[optind], "application") == 0)
    {
        command_application (argc, argv, optind);
    }
    else if (strcasecmp (argv[optind], "transaction") == 0)
    {
        command_transaction (argc, argv, optind);
    }
    else if (strcasecmp (argv[optind], "export") == 0)
    {
        command_export (argc, argv, optind);
    }
    else if (strcasecmp (argv[optind], "import") == 0)
    {
        command_import (argc, argv, optind);
    }
        else if (strcasecmp (argv[optind], "debug") == 0)
        {
                command_debug (argc, argv, optind);
        }
        else if (strcasecmp (argv[optind], "help") == 0)
        {
                command_help (argc, argv, optind);
        }
        else
        {
                fprintf (stderr, "Unrecognized command %s\n", argv[optind]);
                usage ();
        }
}

static void
initialize_configuration (const char *config_filename)
{
    /* Set the DB parameters */
        Arm4dbConfig::setConfig (config_filename);
}

static void
version (void)
{
        printf ("Package %s\n", PACKAGE);
        printf ("Version %s\n", VERSION);
}

static void
usage (void)
{
        printf ("Usage:\n");
#ifdef HAVE_GETOPT_LONG 
        printf ("\tarm4_control --help|-h\n");
        printf ("\t\tShow this help message\n");
        printf ("\tarm4_control --version|-V\n");
        printf ("\t\tDisplay implementation version\n");
        printf ("\tarm4_control [--config|-C config_file] [commands...]\n");
    printf ("\t\t--config specifies a path to the configuration file. The default is /etc/arm4.conf\n");
        printf ("\t\tThe commands 'help' or 'help commands' will show all available commands\n");
#else
        printf ("\tarm4_control -h\n");
        printf ("\t\tShow this help message\n");
        printf ("\tarm4_control -V\n");
        printf ("\t\tDisplay implementation version\n");
        printf ("\tarm4_control [-C config_file] [commands...]\n");
        printf ("\t\t--config specifies a path to the configuration file. The default is /etc/arm4.conf\n");
        printf ("\t\tThe commands 'help' or 'help commands' will show all available commands\n");
#endif
}

int
main (int argc, char *argv[])
{
        int c;
    char config_filename [1024];

    // Initialize the logger
    Logger::getLogger().setName ("arm4_control");
    Logger::getLogger().setFile (stderr);

    /* Set the default config file */
    strcpy (config_filename, "/etc/arm4.conf");

    while (1)
        {
#ifdef HAVE_GETOPT_LONG 
                static struct option long_options[] =
                        {
                                        /* These options set a flag. */
                                        /* These options don't set a flag. We distinguish them by their indices. */
                                {"help",     no_argument,       0, 'h'},
                                {"version",  no_argument,       0, 'V'},
                {"config",   required_argument, 0, 'C'},
                                {0, 0, 0, 0}
                        };

                /* getopt_long stores the option index here. */
                int option_index = 0;
 
                c = getopt_long (argc, argv, "ashVC:",
                                                long_options, &option_index);
#else
                c = getopt (argc, argv, "ashVC:");
#endif 
 
                /* Detect the end of the options. */
                if (c == -1)
                        break;
 
                switch (c)
                {
                case 0:
                        /* If this option set a flag, do nothing else now. */
#ifdef HAVE_GETOPT_LONG 
                        if (long_options[option_index].flag != 0)
                                break;

                        printf ("option %s", long_options[option_index].name);
                        if (optarg)
                                printf (" with arg %s", optarg);
                        printf ("\n");
#endif
                        break;
 
                case '?':
                        /* getopt_long already printed an error message. */
                        break;
                        
                case 'h':
                        usage ();
                        exit (0);

                case 'V':
                        version ();
                        exit (0);

        case 'C':
            strncpy (config_filename, optarg, sizeof(config_filename));
            break;

                default:
                        usage ();
                        abort ();
                }
        }

    initialize_configuration (config_filename);

        if ((argc - optind) < 1)
        {
                usage ();
                exit (0);
        }

        process_command (argc - optind, argv, optind);


        return 0;
}