Menu
▾
▴
[OpenCALEA-devel] SF.net SVN: opencalea: [38] trunk/src
|
From: <nor...@us...> - 2007-05-16 19:17:36
|
Revision: 38
http://opencalea.svn.sourceforge.net/opencalea/?rev=38&view=rev
Author: norm_brandinger
Date: 2007-05-16 12:17:37 -0700 (Wed, 16 May 2007)
Log Message:
-----------
Added structured user input processing to opencalea.c
Added opencalea.c globals to opencalea.h
This update does NOT complete the work on opencalea.c It is only being posted for review. None of the commands are operating yet.
Modified Paths:
--------------
trunk/src/opencalea.c
trunk/src/opencalea.h
Modified: trunk/src/opencalea.c
===================================================================
--- trunk/src/opencalea.c 2007-05-14 22:28:37 UTC (rev 37)
+++ trunk/src/opencalea.c 2007-05-16 19:17:37 UTC (rev 38)
@@ -24,18 +24,20 @@
* SUCH DAMAGE.
*/
+#include <getopt.h>
+
#include "common.h"
#include "msg.h"
#include "calea.h"
#include "opencalea.h"
-void display_prompt();
-void get_input(char *buffer, size_t buffer_len, FILE *file);
-int process_input(char *buffer);
-
+/**
+ * Main Routine
+ */
int main(int argc, char *argv[]) {
char buffer[MAX_LINE+1];
+ int level = STATE_NONE;
setdebug( DEF_DEBUG_LEVEL, DEF_DEBUG_DEST, 1 );
//setdebug( 5, "stdout", 1 );
@@ -43,25 +45,35 @@
parse_commandline(argc, argv);
- for (;;) {
- display_prompt();
+ printf("BETA FOR REVIEW - NON OPERATIONAL\n");
+
+ while(1) {
+ display_prompt(level);
get_input(buffer, MAX_LINE, stdin);
- if (!process_input(buffer))
+ if ( !(level=process_input(level, buffer)) )
break;
}
return 0;
}
-void display_prompt() {
- printf("OpenCALEA> ");
- fflush (stdout);
-}
-
+/**
+ * Get user input from a file pointer
+ */
void get_input(char *buffer, size_t buffer_len, FILE *file) {
size_t last;
bzero(buffer,buffer_len+1);
+
+ /*********************************************************************/
+ /* the next two lines are used to add a dummy value as argv[0]. */
+ /* argv[0] is usually the name used to execute this program. */
+ /* If standard subroutines are used to process this argument vector, */
+ /* for example, getopt, then this argv[0] fix is required. */
+ /*********************************************************************/
+ strncpy(buffer, "opencalea ", 10);
+ buffer+=10;
+
if (fgets (buffer, buffer_len, file)) {
last = strlen (buffer) - 1;
@@ -76,36 +88,568 @@
return;
}
-int process_input(char *buffer) {
+/**
+ * Process a complete line of input from a user
+ * An argv[] vector is created and then each argv is processed
+ * The resulting enum STATE (level) is returned
+ */
+int process_input(int level, char *buffer) {
- char **ap;
- char *argv[MAX_LINE];
- char *inputstring;
- int i, argc;
+ char **ap;
+ char *argv[MAX_LINE];
+ char *inputstring;
+ int argc = 0;
+ /* the following usees strsep to parse a string */
+ /* containing tokens into an argument vector */
+ bzero(argv, MAX_LINE);
+ inputstring = buffer;
+ for (ap = argv; (*ap = strsep(&inputstring, "\r\n\t ")) != NULL;)
+ if (**ap != '\0') {
+ argc++;
+ if (++ap >= &argv[MAX_LINE])
+ break;
+ }
- /* the following used strsep to parse a string containing tokens into an argument vector */
- bzero(argv, sizeof(argv));
- argc = 0;
- inputstring = buffer;
- for (ap = argv; (*ap = strsep(&inputstring, "\r\n\t ")) != NULL;)
- if (**ap != '\0') {
- argc++;
- if (++ap >= &argv[MAX_LINE])
+ // for (int c=0;c<argc;c++) { printf("argv[%d]=%s\n", c, argv[c]); }
+
+ /* nothing to process, just return */
+ if (argc == 1)
+ return level;
+
+ if (argc == 2) {
+ level = process_arg(level, argv[1]);
+ } else if (argc == 3) {
+ level = process_arg(level, argv[1]);
+ level = process_arg(level, argv[2]);
+ } else if (argc == 4) {
+ level = process_arg(level, argv[1]);
+ level = process_arg(level, argv[2]);
+ level = process_arg(level, argv[3]);
+ }
+
+ fflush(stdout);
+ return(level);
+}
+
+
+/**
+ * Display a prompt for the user based upon the current enum STATE (level)
+ */
+void display_prompt(int level) {
+
+ switch (level) {
+ case STATE_NONE:
+ strcpy(prompt, "OpenCALEA>");
break;
+ case STATE_START:
+ strcpy(prompt, "OpenCALEA Start>");
+ break;
+ case STATE_STOP:
+ strcpy(prompt, "OpenCALEA Stop>");
+ break;
+ case STATE_STATUS:
+ strcpy(prompt, "OpenCALEA Status>");
+ break;
+ case STATE_START_INTERCEPT:
+ strcpy(prompt, "OpenCALEA Start Intercept>");
+ break;
+ case STATE_START_DF_COLLECTOR:
+ strcpy(prompt, "OpenCALEA Start df_collector>");
+ break;
+ case STATE_START_CONTROLLERD:
+ strcpy(prompt, "OpenCALEA Start controllerd>");
+ break;
+ case STATE_START_LEA_COLLECTOR:
+ strcpy(prompt, "OpenCALEA Start lea_collector>");
+ break;
+ case STATE_START_TAP:
+ strcpy(prompt, "OpenCALEA Start tap>");
+ break;
+ case STATE_STOP_INTERCEPT:
+ strcpy(prompt, "OpenCALEA Stop Intercept>");
+ break;
+ case STATE_STOP_DF_COLLECTOR:
+ strcpy(prompt, "OpenCALEA Stop df_collector>");
+ break;
+ case STATE_STOP_CONTROLLERD:
+ strcpy(prompt, "OpenCALEA Stop controllerd>");
+ break;
+ case STATE_STOP_LEA_COLLECTOR:
+ strcpy(prompt, "OpenCALEA Stop lea_collector>");
+ break;
+ case STATE_STOP_TAP:
+ strcpy(prompt, "OpenCALEA Stop tap>");
+ break;
+ case STATE_STATUS_INTERCEPT:
+ strcpy(prompt, "OpenCALEA Status Intercept>");
+ break;
+ case STATE_STATUS_DF_COLLECTOR:
+ strcpy(prompt, "OpenCALEA Status df_collector>");
+ break;
+ case STATE_STATUS_CONTROLLERD:
+ strcpy(prompt, "OpenCALEA Status controllerd>");
+ break;
+ case STATE_STATUS_LEA_COLLECTOR:
+ strcpy(prompt, "OpenCALEA Status lea_collector>");
+ break;
+ case STATE_STATUS_TAP:
+ strcpy(prompt, "OpenCALEA Status tap>");
+ break;
+ case STATE_START_INTERCEPT_FILE:
+ strcpy(prompt, "OpenCALEA Start Intercept ");
+ strcat(prompt, file_intercept);
+ strcat(prompt, ">");
+ break;
+ case STATE_START_DF_COLLECTOR_FILE:
+ strcpy(prompt, "OpenCALEA Start df_collector ");
+ strcat(prompt, file_df_collector);
+ strcat(prompt, ">");
+ break;
+ case STATE_START_CONTROLLERD_FILE:
+ strcpy(prompt, "OpenCALEA Start controllerd ");
+ strcat(prompt, file_controllerd);
+ strcat(prompt, ">");
+ break;
+ case STATE_START_LEA_COLLECTOR_FILE:
+ strcpy(prompt, "OpenCALEA Start lea_collector ");
+ strcat(prompt, file_lea_collector);
+ strcat(prompt, ">");
+ break;
+ case STATE_START_TAP_FILE:
+ strcpy(prompt, "OpenCALEA Start tap ");
+ strcat(prompt, file_tap);
+ strcat(prompt, ">");
+ break;
+ case STATE_STOP_INTERCEPT_FILE:
+ strcpy(prompt, "OpenCALEA Stop Intercept ");
+ strcat(prompt, file_intercept);
+ strcat(prompt, ">");
+ break;
+ case STATE_STOP_DF_COLLECTOR_FILE:
+ strcpy(prompt, "OpenCALEA Stop df_collector ");
+ strcat(prompt, file_df_collector);
+ strcat(prompt, ">");
+ break;
+ case STATE_STOP_CONTROLLERD_FILE:
+ strcpy(prompt, "OpenCALEA Stop controllerd ");
+ strcat(prompt, file_controllerd);
+ strcat(prompt, ">");
+ break;
+ case STATE_STOP_LEA_COLLECTOR_FILE:
+ strcpy(prompt, "OpenCALEA Stop lea_collector ");
+ strcat(prompt, file_lea_collector);
+ strcat(prompt, ">");
+ break;
+ case STATE_STOP_TAP_FILE:
+ strcpy(prompt, "OpenCALEA Stop tap ");
+ strcat(prompt, file_tap);
+ strcat(prompt, ">");
+ break;
+ case STATE_STATUS_INTERCEPT_FILE:
+ strcpy(prompt, "OpenCALEA Status Intercept ");
+ strcat(prompt, file_intercept);
+ strcat(prompt, ">");
+ break;
+ case STATE_STATUS_DF_COLLECTOR_FILE:
+ strcpy(prompt, "OpenCALEA Status df_collector ");
+ strcat(prompt, file_df_collector);
+ strcat(prompt, ">");
+ break;
+ case STATE_STATUS_CONTROLLERD_FILE:
+ strcpy(prompt, "OpenCALEA Status controllerd ");
+ strcat(prompt, file_controllerd);
+ strcat(prompt, ">");
+ break;
+ case STATE_STATUS_LEA_COLLECTOR_FILE:
+ strcpy(prompt, "OpenCALEA Status lea_collector ");
+ strcat(prompt, file_lea_collector);
+ strcat(prompt, ">");
+ break;
+ case STATE_STATUS_TAP_FILE:
+ strcpy(prompt, "OpenCALEA Status tap ");
+ strcat(prompt, file_tap);
+ strcat(prompt, ">");
+ break;
+
}
- if ( !strncmp(buffer, "quit", 4) || !strncmp(buffer, "exit", 4) )
- return 0;
+ printf("%s ", prompt);
+ fflush (stdout);
+}
- printf("OpenCALEA> ");
- for (i=0; i<argc; i++) {
- printf("arg[%d]=%s ", i, argv[i]);
+
+/**
+ * Process an argv[] item associated with the current enum STATE (level)
+ * This routine will return a new STATE (level)
+ */
+int process_arg(int level, char *arg) {
+
+ if ( !strncmp(arg, "quit", 4) )
+ return(STATE_QUIT);
+
+ if (arg[0] == '?') {
+ print_help(level);
+ return(level);
}
- printf("\n");
- fflush (stdout);
- return 1;
+ switch (level) {
+ case STATE_NONE:
+ if ( !strncmp(arg, "start", 5) ) {
+ level = STATE_START;
+ } else if ( !strncmp(arg, "stop", 4) ) {
+ level = STATE_STOP;
+ } else if ( !strncmp(arg, "status", 6) ) {
+ level = STATE_STATUS;
+ } else if ( !strncmp(arg, "exit", 4) ) {
+ level = STATE_QUIT;
+ }
+ break;
+ case STATE_START:
+ if ( !strncmp(arg, "intercept", 9) ) {
+ level = STATE_START_INTERCEPT;
+ } else if ( !strncmp(arg, "df_collector", 12) ) {
+ level = STATE_START_DF_COLLECTOR;
+ } else if ( !strncmp(arg, "controllerd", 11) ) {
+ level = STATE_START_CONTROLLERD;
+ } else if ( !strncmp(arg, "lea_collector", 13) ) {
+ level = STATE_START_LEA_COLLECTOR;
+ } else if ( !strncmp(arg, "tap", 3) ) {
+ level = STATE_START_TAP;
+ } else if ( !strncmp(arg, "exit", 4) ) {
+ level = STATE_NONE;
+ }
+ break;
+ case STATE_STOP:
+ if ( !strncmp(arg, "intercept", 9) ) {
+ level = STATE_STOP_INTERCEPT;
+ } else if ( !strncmp(arg, "df_collector", 12) ) {
+ level = STATE_STOP_DF_COLLECTOR;
+ } else if ( !strncmp(arg, "controllerd", 11) ) {
+ level = STATE_STOP_CONTROLLERD;
+ } else if ( !strncmp(arg, "lea_collector", 13) ) {
+ level = STATE_STOP_LEA_COLLECTOR;
+ } else if ( !strncmp(arg, "tap", 3) ) {
+ level = STATE_STOP_TAP;
+ } else if ( !strncmp(arg, "exit", 4) ) {
+ level = STATE_NONE;
+ }
+ break;
+ case STATE_STATUS:
+ if ( !strncmp(arg, "intercept", 9) ) {
+ level = STATE_STATUS_INTERCEPT;
+ } else if ( !strncmp(arg, "df_collector", 12) ) {
+ level = STATE_STATUS_DF_COLLECTOR;
+ } else if ( !strncmp(arg, "controllerd", 11) ) {
+ level = STATE_STATUS_CONTROLLERD;
+ } else if ( !strncmp(arg, "lea_collector", 13) ) {
+ level = STATE_STATUS_LEA_COLLECTOR;
+ } else if ( !strncmp(arg, "tap", 3) ) {
+ level = STATE_STATUS_TAP;
+ } else if ( !strncmp(arg, "exit", 4) ) {
+ level = STATE_NONE;
+ }
+ break;
+
+ case STATE_START_INTERCEPT:
+ if ( !strncmp(arg, "exit", 4) ) {
+ level = STATE_START;
+ } else {
+ strcpy(file_intercept, arg);
+ level = STATE_START_INTERCEPT_FILE;
+ }
+ break;
+ case STATE_START_DF_COLLECTOR:
+ if ( !strncmp(arg, "exit", 4) ) {
+ level = STATE_START;
+ } else {
+ strcpy(file_df_collector, arg);
+ level = STATE_START_DF_COLLECTOR_FILE;
+ }
+ break;
+ case STATE_START_CONTROLLERD:
+ if ( !strncmp(arg, "exit", 4) ) {
+ level = STATE_START;
+ } else {
+ strcpy(file_controllerd, arg);
+ level = STATE_START_CONTROLLERD_FILE;
+ }
+ break;
+ case STATE_START_LEA_COLLECTOR:
+ if ( !strncmp(arg, "exit", 4) ) {
+ level = STATE_START;
+ } else {
+ strcpy(file_lea_collector, arg);
+ level = STATE_START_LEA_COLLECTOR_FILE;
+ }
+ break;
+ case STATE_START_TAP:
+ if ( !strncmp(arg, "exit", 4) ) {
+ level = STATE_START;
+ } else {
+ strcpy(file_tap, arg);
+ level = STATE_START_TAP_FILE;
+ }
+ break;
+ case STATE_STOP_INTERCEPT:
+ if ( !strncmp(arg, "exit", 4) ) {
+ level = STATE_STOP;
+ } else {
+ strcpy(file_intercept, arg);
+ level = STATE_STOP_INTERCEPT_FILE;
+ }
+ break;
+ case STATE_STOP_DF_COLLECTOR:
+ if ( !strncmp(arg, "exit", 4) ) {
+ level = STATE_STOP;
+ } else {
+ strcpy(file_df_collector, arg);
+ level = STATE_STOP_DF_COLLECTOR_FILE;
+ }
+ break;
+ case STATE_STOP_CONTROLLERD:
+ if ( !strncmp(arg, "exit", 4) ) {
+ level = STATE_STOP;
+ } else {
+ strcpy(file_controllerd, arg);
+ level = STATE_STOP_CONTROLLERD_FILE;
+ }
+ break;
+ case STATE_STOP_LEA_COLLECTOR:
+ if ( !strncmp(arg, "exit", 4) ) {
+ level = STATE_STOP;
+ } else {
+ strcpy(file_lea_collector, arg);
+ level = STATE_STOP_LEA_COLLECTOR_FILE;
+ }
+ break;
+ case STATE_STOP_TAP:
+ if ( !strncmp(arg, "exit", 4) ) {
+ level = STATE_STOP;
+ } else {
+ strcpy(file_tap, arg);
+ level = STATE_STOP_TAP_FILE;
+ }
+ break;
+ case STATE_STATUS_INTERCEPT:
+ if ( !strncmp(arg, "exit", 4) ) {
+ level = STATE_STATUS;
+ } else {
+ strcpy(file_intercept, arg);
+ level = STATE_STATUS_INTERCEPT_FILE;
+ }
+ break;
+ case STATE_STATUS_DF_COLLECTOR:
+ if ( !strncmp(arg, "exit", 4) ) {
+ level = STATE_STATUS;
+ } else {
+ strcpy(file_df_collector, arg);
+ level = STATE_STATUS_DF_COLLECTOR_FILE;
+ }
+ break;
+ case STATE_STATUS_CONTROLLERD:
+ if ( !strncmp(arg, "exit", 4) ) {
+ level = STATE_STATUS;
+ } else {
+ strcpy(file_controllerd, arg);
+ level = STATE_STATUS_CONTROLLERD_FILE;
+ }
+ break;
+ case STATE_STATUS_LEA_COLLECTOR:
+ if ( !strncmp(arg, "exit", 4) ) {
+ level = STATE_STATUS;
+ } else {
+ strcpy(file_lea_collector, arg);
+ level = STATE_STATUS_LEA_COLLECTOR_FILE;
+ }
+ break;
+ case STATE_STATUS_TAP:
+ if ( !strncmp(arg, "exit", 4) ) {
+ level = STATE_STATUS;
+ } else {
+ strcpy(file_tap, arg);
+ level = STATE_STATUS_TAP_FILE;
+ }
+ break;
+ case STATE_START_INTERCEPT_FILE:
+ if ( !strncmp(arg, "exit", 4) ) {
+ level = STATE_START_INTERCEPT;
+ } else {
+ printf("reading file: %s ... (not really)\n", file_intercept);
+ }
+ break;
+ case STATE_START_DF_COLLECTOR_FILE:
+ if ( !strncmp(arg, "exit", 4) ) {
+ level = STATE_START_DF_COLLECTOR;
+ } else {
+ printf("reading file: %s ... (not really)\n", file_df_collector);
+ }
+ break;
+ case STATE_START_CONTROLLERD_FILE:
+ if ( !strncmp(arg, "exit", 4) ) {
+ level = STATE_START_CONTROLLERD;
+ } else {
+ printf("reading file: %s ... (not really)\n", file_controllerd);
+ }
+ break;
+ case STATE_START_LEA_COLLECTOR_FILE:
+ if ( !strncmp(arg, "exit", 4) ) {
+ level = STATE_START_LEA_COLLECTOR;
+ } else {
+ printf("reading file: %s ... (not really)\n", file_lea_collector);
+ }
+ break;
+ case STATE_START_TAP_FILE:
+ if ( !strncmp(arg, "exit", 4) ) {
+ level = STATE_START_TAP;
+ } else {
+ printf("reading file: %s ... (not really)\n", file_tap);
+ }
+ break;
+ case STATE_STOP_INTERCEPT_FILE:
+ if ( !strncmp(arg, "exit", 4) ) {
+ level = STATE_STOP_INTERCEPT;
+ } else {
+ printf("reading file: %s ... (not really)\n", file_intercept);
+ }
+ break;
+ case STATE_STOP_DF_COLLECTOR_FILE:
+ if ( !strncmp(arg, "exit", 4) ) {
+ level = STATE_STOP_DF_COLLECTOR;
+ } else {
+ printf("reading file: %s ... (not really)\n", file_df_collector);
+ }
+ break;
+ case STATE_STOP_CONTROLLERD_FILE:
+ if ( !strncmp(arg, "exit", 4) ) {
+ level = STATE_STOP_CONTROLLERD;
+ } else {
+ printf("reading file: %s ... (not really)\n", file_controllerd);
+ }
+ break;
+ case STATE_STOP_LEA_COLLECTOR_FILE:
+ if ( !strncmp(arg, "exit", 4) ) {
+ level = STATE_STOP_LEA_COLLECTOR;
+ } else {
+ printf("reading file: %s ... (not really)\n", file_lea_collector);
+ }
+ break;
+ case STATE_STOP_TAP_FILE:
+ if ( !strncmp(arg, "exit", 4) ) {
+ level = STATE_STOP_TAP;
+ } else {
+ printf("reading file: %s ... (not really)\n", file_tap);
+ }
+ break;
+ case STATE_STATUS_INTERCEPT_FILE:
+ if ( !strncmp(arg, "exit", 4) ) {
+ level = STATE_STATUS_INTERCEPT;
+ } else {
+ printf("reading file: %s ... (not really)\n", file_intercept);
+ }
+ break;
+ case STATE_STATUS_DF_COLLECTOR_FILE:
+ if ( !strncmp(arg, "exit", 4) ) {
+ level = STATE_STATUS_DF_COLLECTOR;
+ } else {
+ printf("reading file: %s ... (not really)\n", file_df_collector);
+ }
+ break;
+ case STATE_STATUS_CONTROLLERD_FILE:
+ if ( !strncmp(arg, "exit", 4) ) {
+ level = STATE_STATUS_CONTROLLERD;
+ } else {
+ printf("reading file: %s ... (not really)\n", file_controllerd);
+ }
+ break;
+ case STATE_STATUS_LEA_COLLECTOR_FILE:
+ if ( !strncmp(arg, "exit", 4) ) {
+ level = STATE_STATUS_LEA_COLLECTOR;
+ } else {
+ printf("reading file: %s ... (not really)\n", file_lea_collector);
+ }
+ break;
+ case STATE_STATUS_TAP_FILE:
+ if ( !strncmp(arg, "exit", 4) ) {
+ level = STATE_STATUS_TAP;
+ } else {
+ printf("reading file: %s ... (not really)\n", file_tap);
+ }
+ break;
+
+ }
+
+ return level;
+}
+
+/**
+ * Print help text based on the enum STATE (level)
+ */
+void print_help(int level) {
+
+ /* display help line based on the current level */
+ switch (level) {
+ case STATE_NONE:
+ printf("Commands: start, stop, status, exit, quit\n");
+ break;
+ case STATE_START:
+ printf("Start: controllerd, df_collector, tap, intercept, lea_collector, exit, quit\n");
+ break;
+ case STATE_STOP:
+ printf("Stop: controllerd, df_collector, tap, intercept, lea_collector, exit, quit\n");
+ break;
+ case STATE_STATUS:
+ printf("Status: controllerd, df_collector, tap, intercept, lea_collector, exit, quit\n");
+ break;
+ case STATE_START_INTERCEPT:
+ printf("Start Intercept: <file>\n");
+ break;
+ case STATE_START_DF_COLLECTOR:
+ printf("Start df_collector: <file>\n");
+ break;
+ case STATE_START_TAP:
+ printf("Start tap: <file>\n");
+ break;
+ case STATE_START_LEA_COLLECTOR:
+ printf("Start lea_collector: <file>\n");
+ break;
+ case STATE_START_CONTROLLERD:
+ printf("Start controllerd: <file>\n");
+ break;
+ case STATE_STOP_INTERCEPT:
+ printf("Stop Intercept: <file>\n");
+ break;
+ case STATE_STOP_DF_COLLECTOR:
+ printf("Stop df_collector: <file>\n");
+ break;
+ case STATE_STOP_TAP:
+ printf("Stop tap: <file>\n");
+ break;
+ case STATE_STOP_LEA_COLLECTOR:
+ printf("Stop lea_collector: <file>\n");
+ break;
+ case STATE_STOP_CONTROLLERD:
+ printf("Stop controllerd: <file>\n");
+ break;
+ case STATE_STATUS_INTERCEPT:
+ printf("Status Intercept: <file>\n");
+ break;
+ case STATE_STATUS_DF_COLLECTOR:
+ printf("Status df_collector: <file>\n");
+ break;
+ case STATE_STATUS_TAP:
+ printf("Status tap: <file>\n");
+ break;
+ case STATE_STATUS_LEA_COLLECTOR:
+ printf("Status lea_collector: <file>\n");
+ break;
+ case STATE_STATUS_CONTROLLERD:
+ printf("Status controllerd: <file>\n");
+ break;
+ }
+
+ fflush(stdout);
+ return;
}
@@ -164,10 +708,10 @@
debug_4 ( "got opt %c: %s", i, optarg );
break;
case 'h': // help
- usage();
+ print_usage();
exit ( 0 );
default:
- usage ();
+ print_usage ();
exit ( 1 );
}
}
@@ -263,7 +807,7 @@
return;
}
-void usage(void) {
- printf("opencalea usage...\n");
+void print_usage(void) {
+ printf("OpenCALEA usage...\n");
return;
}
Modified: trunk/src/opencalea.h
===================================================================
--- trunk/src/opencalea.h 2007-05-14 22:28:37 UTC (rev 37)
+++ trunk/src/opencalea.h 2007-05-16 19:17:37 UTC (rev 38)
@@ -29,7 +29,12 @@
/* function prototypes */
void parse_commandline(int argc, char *argv[]);
-void usage(void);
+void print_usage(void);
+void display_prompt(int level);
+void get_input(char *buffer, size_t buffer_len, FILE *file);
+int process_arg(int level, char *arg);
+int process_input(int level, char *buffer);
+void print_help(int level);
char *prog_name = "opencalea";
int syslog_facility = DEF_SYSLOG_FACILITY;
@@ -55,4 +60,51 @@
char *debug_file_name = NULL;
char *log_file_name = NULL;
+enum e_state
+{
+ STATE_QUIT = 0,
+ STATE_NONE,
+ STATE_START,
+ STATE_START_INTERCEPT,
+ STATE_START_INTERCEPT_FILE,
+ STATE_START_DF_COLLECTOR,
+ STATE_START_DF_COLLECTOR_FILE,
+ STATE_START_CONTROLLERD,
+ STATE_START_CONTROLLERD_FILE,
+ STATE_START_LEA_COLLECTOR,
+ STATE_START_LEA_COLLECTOR_FILE,
+ STATE_START_TAP,
+ STATE_START_TAP_FILE,
+ STATE_STOP,
+ STATE_STOP_INTERCEPT,
+ STATE_STOP_INTERCEPT_FILE,
+ STATE_STOP_DF_COLLECTOR,
+ STATE_STOP_DF_COLLECTOR_FILE,
+ STATE_STOP_CONTROLLERD,
+ STATE_STOP_CONTROLLERD_FILE,
+ STATE_STOP_LEA_COLLECTOR,
+ STATE_STOP_LEA_COLLECTOR_FILE,
+ STATE_STOP_TAP,
+ STATE_STOP_TAP_FILE,
+ STATE_STATUS,
+ STATE_STATUS_INTERCEPT,
+ STATE_STATUS_INTERCEPT_FILE,
+ STATE_STATUS_DF_COLLECTOR,
+ STATE_STATUS_DF_COLLECTOR_FILE,
+ STATE_STATUS_CONTROLLERD,
+ STATE_STATUS_CONTROLLERD_FILE,
+ STATE_STATUS_LEA_COLLECTOR,
+ STATE_STATUS_LEA_COLLECTOR_FILE,
+ STATE_STATUS_TAP,
+ STATE_STATUS_TAP_FILE
+};
+
+char prompt[MAX_LINE] = "OpenCALEA>";
+char file_intercept[MAX_LINE];
+char file_df_collector[MAX_LINE];
+char file_controllerd[MAX_LINE];
+char file_lea_collector[MAX_LINE];
+char file_tap[MAX_LINE];
+
+
#endif
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
