X-Git-Url: https://git.ucc.asn.au/?a=blobdiff_plain;f=server%2Fmain.c;h=ecdf0682ef750ce29911001d281aed61dfeb025f;hb=f858232d7c564f14e6d2fb9d616f8e12a1ec9171;hp=71f2aba24ef4b4e5f52e61524a6013b9130c191d;hpb=b1a8334f97f84e10ee9cef96377bbdcfbf5f945c;p=matches%2FMCTX3420.git diff --git a/server/main.c b/server/main.c index 71f2aba..ecdf068 100644 --- a/server/main.c +++ b/server/main.c @@ -1,20 +1,20 @@ /** * @file main.c - * @purpose Entry point to the program, starts threads, handles cleanup on program exit + * @brief main and its helper functions, signal handling and cleanup functions */ -#define _POSIX_C_SOURCE 200809L // For strsignal to work +// --- Custom headers --- // +#include "common.h" +#include "options.h" +#include "sensor.h" +#include "actuator.h" +#include "control.h" +#include "pin_test.h" +#include "bbb_pin_defines.h" // --- Standard headers --- // -#include -#include +#include // for system logging #include // for signal handling -#include // string functions -#include - -// --- Custom headers --- // -#include "log.h" -#include "options.h" // --- Variable definitions --- // Options g_options; // options passed to program through command line arguments @@ -22,52 +22,152 @@ Options g_options; // options passed to program through command line arguments // --- Function definitions --- // /** - * @funct ParseArguments - * @purpose Parse command line arguments, set up an options variable - * @param argc - Num args - * @param argv - Array of args - * @param opts - Pointer to options. &g_options + * Parse command line arguments, initialise g_options + * @param argc - Number of arguments + * @param argv - Array of argument strings */ -void ParseArguments(int argc, char ** argv, Options * opts) +void ParseArguments(int argc, char ** argv) { - opts->program = argv[0]; // program name - opts->verbosity = LOGDEBUG; // default log level - Log(LOGDEBUG, "ParseArguments", "Called as %s with %d arguments.", opts->program, argc); + + + g_options.program = argv[0]; // program name + g_options.verbosity = LOGDEBUG; // default log level + gettimeofday(&(g_options.start_time), NULL); // Start time + + + g_options.auth_method = AUTH_NONE; // Don't use authentication + g_options.auth_uri = ""; // + g_options.ldap_base_dn = ""; + + + + for (int i = 1; i < argc; ++i) + { + if (argv[i][0] != '-') + Fatal("Unexpected argv[%d] - %s", i, argv[i]); + + if (i+1 >= argc || argv[i+1][0] == '-') + Fatal("No argument following switch %s", argv[i]); + + if (strlen(argv[i]) > 2) + Fatal("Human readable switches are not supported."); + + char * end = NULL; + switch (argv[i][1]) + { + // Set program verbosity + case 'v': + g_options.verbosity = strtol(argv[++i], &end, 10); + break; + // Enable/Disable pin test + case 'p': + g_options.enable_pin = !(strtol(argv[++i], &end, 10)); + break; + // LDAP URI + case 'A': + g_options.auth_uri = argv[++i]; + break; + // LDAP DN + case 'd': + g_options.ldap_base_dn = argv[++i]; + break; + default: + Fatal("Unrecognised switch %s", argv[i]); + break; + } + + if (end != NULL && *end != '\0') + Fatal("argv[%d] -%c requires an integer (got \"%s\" instead)", i-1, argv[i-1][0], argv[i]); + } + + Log(LOGDEBUG, "Verbosity: %d", g_options.verbosity); + Log(LOGDEBUG, "Pin Module Enabled: %d", g_options.enable_pin); + Log(LOGDEBUG, "Auth URI: %s", g_options.auth_uri); + Log(LOGDEBUG, "LDAP Base DN: %s", g_options.ldap_base_dn); + + if (g_options.auth_uri[0] != '\0') + { + //HACK... + if (PathExists(g_options.auth_uri)) + g_options.auth_method = AUTH_SHADOW; + else + g_options.auth_method = AUTH_LDAP; + } + } /** - * @funct SignalHandler - * @purpose Handle signals - * @param sig - The signal + * Handle a signal + * @param signal - The signal number */ -void SignalHandler(int sig) +//TODO: Something that gets massively annoying with threads is that you can't predict which one gets the signal +// There are ways to deal with this, but I can't remember them +// Probably sufficient to just call Thread_QuitProgram here +void SignalHandler(int signal) { // At the moment just always exit. // Call `exit` so that Cleanup will be called to... clean up. - Log(LOGWARN, "SignalHandler", "Got signal %d (%s). Exiting.", sig, strsignal(sig)); - exit(sig); + Log(LOGWARN, "Got signal %d (%s). Exiting.", signal, strsignal(signal)); + + //exit(signal); } /** - * @funct Cleanup - * @purpose Called when program exits + * Cleanup before the program exits */ void Cleanup() { - Log(LOGDEBUG, "Cleanup", "Begin cleanup."); - Log(LOGDEBUG, "Cleanup", "Finish cleanup."); + Log(LOGDEBUG, "Begin cleanup."); + Log(LOGDEBUG, "Finish cleanup."); } /** - * @funct main - * @purpose Main entry point; start worker threads, setup signal handling, wait for threads to exit, exit + * Main entry point; start worker threads, setup signal handling, wait for threads to exit, exit * @param argc - Num args * @param argv - Args * @returns 0 on success, error code on failure + * NOTE: NEVER USE exit(3)! Instead call Thread_QuitProgram */ int main(int argc, char ** argv) { + // Open log before calling ParseArguments (since ParseArguments may call the Log functions) + openlog("mctxserv", LOG_PID | LOG_PERROR, LOG_USER); + Log(LOGINFO, "Server started"); + + ParseArguments(argc, argv); + + //Open the system log + + // signal handler + //TODO: Make this work + /* + int signals[] = {SIGINT, SIGSEGV, SIGTERM}; + for (int i = 0; i < sizeof(signals)/sizeof(int); ++i) + { + signal(signals[i], SignalHandler); + } + */ + Sensor_Init(); + Actuator_Init(); + Pin_Init(); + //Sensor_StartAll("test"); + //Actuator_StartAll("test"); + const char *ret; + if ((ret = Control_SetMode(CONTROL_START, "test")) != NULL) + Fatal("Control_SetMode failed with '%s'", ret); + + // run request thread in the main thread + FCGI_RequestLoop(NULL); + + if ((ret = Control_SetMode(CONTROL_STOP, "test")) != NULL) + Fatal("Control_SetMode failed with '%s'", ret); + //Sensor_StopAll(); + //Actuator_StopAll(); + + Pin_Close(); + + Cleanup(); return 0; }