mctr2/cli/Cli.cc

   1 /******************************************************************************
   2  * Copyright (c) 2000-2016 Ericsson Telecom AB
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Eclipse Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/epl-v10.html
   7  *
   8  * Contributors:
   9  *   Balasko, Jeno
  10  *   Baranyi, Botond
  11  *   Bene, Tamas
  12  *   Beres, Szabolcs
  13  *   Delic, Adam
  14  *   Forstner, Matyas
  15  *   Gecse, Roland
  16  *   Kovacs, Ferenc
  17  *   Lovassy, Arpad
  18  *   Raduly, Csaba
  19  *   Szabados, Kristof
  20  *   Szabo, Janos Zoltan – initial implementation
  21  *   Szalai, Gabor
  22  *   Zalanyi, Balazs Andor
  23  *   Roland Gecse - author
  24  *
  25  ******************************************************************************/
  26 //
  27 // Description:           Implementation file for Cli
  28 //
  29 //----------------------------------------------------------------------------
  30 #include "Cli.h"
  31 #include "../mctr/MainController.h"
  32
  33 #include <stdio.h>
  34 #include "../editline/libedit/src/editline/readline.h"
  35 #include <ctype.h>
  36 #include <string.h>
  37 #include <errno.h>
  38 #include <stdlib.h>
  39 #include <pthread.h>
  40 #include <arpa/inet.h>
  41 #include "../../common/version_internal.h"
  42 #include "../../common/memory.h"
  43 #include "../../common/config_preproc.h"
  44 #include "../../core/DebugCommands.hh"
  45
  46 #define PROMPT "MC2> "
  47 #define CMTC_TEXT "cmtc"
  48 #define SMTC_TEXT "smtc"
  49 #define EMTC_TEXT "emtc"
  50 #define STOP_TEXT "stop"
  51 #define PAUSE_TEXT "pause"
  52 #define CONTINUE_TEXT "continue"
  53 #define INFO_TEXT "info"
  54 #define HELP_TEXT "help"
  55 #define RECONF_TEXT "reconf"
  56 #define LOG_TEXT "log"
  57 #define SHELL_TEXT "!"
  58 #define EXIT_TEXT "quit"
  59 #define EXIT_TEXT2 "exit"
  60 #define BATCH_TEXT "batch"
  61 #define SHELL_ESCAPE '!'
  62 #define TTCN3_HISTORY_FILENAME ".ttcn3_history"
  63
  64 using mctr::MainController;
  65 using namespace cli;
  66
  67 /**
  68  * shell_mode == TRUE while editing a command line that is passed to the shell
  69  */
  70 static boolean shell_mode;
  71
  72 struct Command {
  73   const char *name;
  74   callback_t callback_function;
  75   const char *synopsis;
  76   const char *description;
  77 };
  78
  79 static const Command command_list[] = {
  80   { CMTC_TEXT, &Cli::cmtcCallback, CMTC_TEXT " [hostname]",
  81     "Create the MTC." },
  82   { SMTC_TEXT, &Cli::smtcCallback,
  83     SMTC_TEXT " [module_name[[.control]|.testcase_name|.*]",
  84     "Start MTC with control part, test case or all test cases." },
  85   { STOP_TEXT, &Cli::stopCallback, STOP_TEXT,
  86     "Stop test execution." },
  87   { PAUSE_TEXT, &Cli::pauseCallback, PAUSE_TEXT " [on|off]",
  88     "Set whether to interrupt test execution after each "
  89     "test case." },
  90   { CONTINUE_TEXT, &Cli::continueCallback, CONTINUE_TEXT,
  91     "Resumes interrupted test execution." },
  92   { EMTC_TEXT, &Cli::emtcCallback, EMTC_TEXT, "Terminate MTC." },
  93   { LOG_TEXT, &Cli::logCallback, LOG_TEXT " [on|off]",
  94     "Enable/disable console logging." },
  95   { INFO_TEXT, &Cli::infoCallback, INFO_TEXT,
  96     "Display test configuration information." },
  97   { RECONF_TEXT, &Cli::reconfCallback, RECONF_TEXT " [config_file]",
  98     "Reload configuration file." },
  99   { HELP_TEXT, &Cli::helpCallback, HELP_TEXT " <command>",
 100     "Display help on command." },
 101   { SHELL_TEXT, &Cli::shellCallback, SHELL_TEXT "[shell cmds]",
 102     "Execute commands in subshell." },
 103   { EXIT_TEXT, &Cli::exitCallback, EXIT_TEXT, "Exit Main Controller." },
 104   { EXIT_TEXT2, &Cli::exitCallback, EXIT_TEXT2, "Exit Main Controller." },
 105   { BATCH_TEXT, &Cli::executeBatchFile, BATCH_TEXT " <batch_file>",
 106     "Run commands from batch file." },
 107   { NULL, NULL, NULL, NULL }
 108 };
 109
 110 struct DebugCommand {
 111   const char *name;
 112   int commandID;
 113   const char *synopsis;
 114   const char *description;
 115 };
 116
 117 static const DebugCommand debug_command_list[] = {
 118   { D_SWITCH_TEXT, D_SWITCH, D_SWITCH_TEXT " on|off",
 119     "Switch the debugger on or off." },
 120   { D_SET_BREAKPOINT_TEXT, D_SET_BREAKPOINT,
 121     D_SET_BREAKPOINT_TEXT " <module> <line> [<batch_file>]",
 122     "Add a breakpoint at the specified location, or change the batch file of "
 123     " an existing breakpoint." },
 124   { D_REMOVE_BREAKPOINT_TEXT, D_REMOVE_BREAKPOINT,
 125     D_REMOVE_BREAKPOINT_TEXT " all|<module> [all|<line>]", "Remove a breakpoint, "
 126     "or all breakpoints from a module, or all breakpoints from all modules." },
 127   { D_SET_AUTOMATIC_BREAKPOINT_TEXT, D_SET_AUTOMATIC_BREAKPOINT,
 128     D_SET_AUTOMATIC_BREAKPOINT_TEXT " error|fail on|off [<batch_file>]",
 129     "Switch an automatic breakpoint (truggered by an event) on or off, and/or "
 130     "change its batch file." },
 131   { D_SET_OUTPUT_TEXT, D_SET_OUTPUT,
 132     D_SET_OUTPUT_TEXT " console|file|both [file_name]",
 133     "Set the output of the debugger." },
 134   { D_SET_GLOBAL_BATCH_FILE_TEXT, D_SET_GLOBAL_BATCH_FILE,
 135     D_SET_GLOBAL_BATCH_FILE_TEXT " on|off [batch_file_name]",
 136     "Set whether a batch file should be executed automatically when test execution "
 137     "is halted (breakpoint-specific batch files override this setting)." },
 138   { D_SET_COMPONENT_TEXT, D_SET_COMPONENT,
 139     D_SET_COMPONENT_TEXT " mtc|<component_reference>",
 140     "Set the test component to print debug information from." },
 141   { D_PRINT_CALL_STACK_TEXT, D_PRINT_CALL_STACK, D_PRINT_CALL_STACK_TEXT,
 142     "Print call stack." },
 143   { D_SET_STACK_LEVEL_TEXT, D_SET_STACK_LEVEL, D_SET_STACK_LEVEL_TEXT " <level>",
 144     "Set the stack level to print debug information from." },
 145   { D_LIST_VARIABLES_TEXT, D_LIST_VARIABLES,
 146     D_LIST_VARIABLES_TEXT " local|global|comp|all [pattern]",
 147     "List variable names." },
 148   { D_PRINT_VARIABLE_TEXT, D_PRINT_VARIABLE,
 149     D_PRINT_VARIABLE_TEXT " <variable_name>|$ [{ <variable_name>|$}]",
 150     "Print current value of one or more variables ('$' is substituted with the "
 151     "result of the last " D_LIST_VARIABLES_TEXT " command)." },
 152   { D_OVERWRITE_VARIABLE_TEXT, D_OVERWRITE_VARIABLE,
 153     D_OVERWRITE_VARIABLE_TEXT " <variable_name> <value>",
 154     "Overwrite the current value of a variable." },
 155   { D_PRINT_SNAPSHOTS_TEXT, D_PRINT_SNAPSHOTS, D_PRINT_SNAPSHOTS_TEXT,
 156     "Print snapshots of function calls until this point." },
 157   // D_SET_SNAPSHOT_BEHAVIOR_TEXT
 158   { D_STEP_OVER_TEXT, D_STEP_OVER, D_STEP_OVER_TEXT,
 159     "Resume test execution until the next line of code (in this function or the "
 160     "caller function)." },
 161   { D_STEP_INTO_TEXT, D_STEP_INTO, D_STEP_INTO_TEXT,
 162     "Resume test execution until the next line of code (on any stack level)." },
 163   { D_STEP_OUT_TEXT, D_STEP_OUT, D_STEP_OUT_TEXT,
 164     "Resume test execution until the next line of code in the caller function." },
 165   { D_RUN_TO_CURSOR_TEXT, D_RUN_TO_CURSOR, D_RUN_TO_CURSOR_TEXT " <module> <line>",
 166     "Resume test execution until the specified location." },
 167   { D_HALT_TEXT, D_HALT, D_HALT_TEXT, "Halt test execution." },
 168   { D_CONTINUE_TEXT, D_CONTINUE, D_CONTINUE_TEXT, "Resume halted test execution." },
 169   { D_EXIT_TEXT, D_EXIT, D_EXIT_TEXT " test|all",
 170     "Exit the current test or the execution of all tests." },
 171   { NULL, D_ERROR, NULL, NULL }
 172 };
 173
 174 Cli::Cli()
 175 {
 176   loggingEnabled = TRUE;
 177   exitFlag = FALSE;
 178   waitState = WAIT_NOTHING;
 179   executeListIndex = 0;
 180
 181   if (pthread_mutex_init(&mutex, NULL)) {
 182     perror("Cli::Cli: pthread_mutex_init failed.");
 183     exit(EXIT_FAILURE);
 184   }
 185   if (pthread_cond_init(&cond, NULL)) {
 186     perror("Cli::Cli: pthread_cond_init failed.");
 187     exit(EXIT_FAILURE);
 188   }
 189 }
 190
 191 Cli::~Cli()
 192 {
 193   pthread_mutex_destroy(&mutex);
 194   pthread_cond_destroy(&cond);
 195 }
 196
 197 //----------------------------------------------------------------------------
 198 // MANDATORY
 199
 200 int Cli::enterLoop(int argc, char *argv[])
 201 {
 202   // Parameter check: mctr [config file name]
 203   if (argc > 2) {
 204     printUsage(argv[0]);
 205     return EXIT_FAILURE;
 206   }
 207
 208   printWelcome();
 209
 210   if (argc == 2) {
 211     printf("Using configuration file: %s\n", argv[1]);
 212     if (process_config_read_file(argv[1], &mycfg)) {
 213       puts("Error was found in the configuration file. Exiting.");
 214       cleanUp();
 215       return EXIT_FAILURE;
 216     }
 217     else {
 218       MainController::set_kill_timer(mycfg.kill_timer);
 219
 220       for (int i = 0; i < mycfg.group_list_len; ++i) {
 221         MainController::add_host(mycfg.group_list[i].group_name,
 222           mycfg.group_list[i].host_name);
 223       }
 224
 225       for (int i = 0; i < mycfg.component_list_len; ++i) {
 226         MainController::assign_component(mycfg.component_list[i].host_or_group,
 227           mycfg.component_list[i].component);
 228       }
 229     }
 230   }
 231
 232   int ret_val;
 233   if (mycfg.num_hcs <= 0) ret_val = interactiveMode();
 234   else ret_val = batchMode();
 235
 236   cleanUp();
 237   return ret_val;
 238 }
 239
 240 //----------------------------------------------------------------------------
 241 // MANDATORY
 242
 243 void Cli::status_change()
 244 {
 245   lock();
 246   if (waitState != WAIT_NOTHING && conditionHolds(waitState)) {
 247     waitState = WAIT_NOTHING;
 248     signal();
 249   }
 250   unlock();
 251 }
 252
 253 //----------------------------------------------------------------------------
 254 // MANDATORY
 255
 256 void Cli::error(int /*severity*/, const char *message)
 257 {
 258   printf("Error: %s\n", message);
 259   fflush(stdout);
 260   // TODO: Error handling based on the MC state where the error happened
 261 }
 262
 263 //----------------------------------------------------------------------------
 264 // MANDATORY
 265
 266 void Cli::notify(const struct timeval *timestamp, const char *source,
 267   int /*severity*/, const char *message)
 268 {
 269   if (loggingEnabled)
 270   {
 271     switch(mycfg.tsformat){
 272       case TSF_TIME:       // handled together
 273       case TSF_DATE_TIME:
 274         {
 275           time_t tv_sec = timestamp->tv_sec;
 276           struct tm *lt = localtime(&tv_sec);
 277           if (lt == NULL) {
 278             printf("localtime() call failed.");
 279             printf("%s: %s\n", source, message);
 280             fflush(stdout);
 281             break;
 282           }
 283           if (mycfg.tsformat == TSF_TIME) {
 284             printf("%02d:%02d:%02d.%06ld %s: %s\n",
 285                   lt->tm_hour, lt->tm_min, lt->tm_sec, timestamp->tv_usec,source, message);
 286           } else {
 287             static const char * const month_names[] = { "Jan", "Feb", "Mar",
 288               "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
 289             printf("%4d/%s/%02d %02d:%02d:%02d.%06ld  %s: %s\n",
 290                              lt->tm_year + 1900, month_names[lt->tm_mon],
 291                              lt->tm_mday, lt->tm_hour, lt->tm_min, lt->tm_sec,
 292                              timestamp->tv_usec
 293                              ,source, message);
 294           }
 295         }
 296         fflush(stdout);
 297         break;
 298       case TSF_SEC:
 299         printf("%ld.%06ld %s: %s\n", (long)timestamp->tv_sec, timestamp->tv_usec, source, message);
 300         fflush(stdout);
 301
 302         break;
 303       default:
 304         printf("%s: %s\n", source, message);
 305         fflush(stdout);
 306         break;
 307     }
 308   }
 309 }
 310
 311 //----------------------------------------------------------------------------
 312 // PRIVATE
 313
 314 void Cli::cleanUp()
 315 {
 316 }
 317
 318 //----------------------------------------------------------------------------
 319 // PRIVATE
 320
 321 void Cli::printWelcome()
 322 {
 323   printf("\n"
 324     "*************************************************************************\n"
 325     "* TTCN-3 Test Executor - Main Controller 2                              *\n"
 326     "* Version: %-40s                     *\n"
 327     "* Copyright (c) 2000-2016 Ericsson Telecom AB                           *\n"
 328     "* All rights reserved. This program and the accompanying materials      *\n"
 329     "* are made available under the terms of the Eclipse Public License v1.0 *\n"
 330     "* which accompanies this distribution, and is available at              *\n"
 331     "* http://www.eclipse.org/legal/epl-v10.html                             *\n"
 332     "*************************************************************************\n"
 333     "\n", PRODUCT_NUMBER);
 334 }
 335
 336 void Cli::printUsage(const char *prg_name)
 337 {
 338   fprintf(stderr,
 339     "TTCN-3 Test Executor - Main Controller 2\n"
 340     "Version: " PRODUCT_NUMBER "\n\n"
 341     "usage: %s [configuration_file]\n"
 342     "where: the optional 'configuration_file' parameter specifies the name "
 343     "and\nlocation of the main controller configuration file"
 344     "\n", prg_name);
 345 }
 346
 347 //----------------------------------------------------------------------------
 348 // PRIVATE
 349
 350 int Cli::interactiveMode()
 351 {
 352   // Initialize history library
 353   using_history();
 354   // Tailor $HOME/...
 355   const char *home_directory = getenv("HOME");
 356   if(home_directory == NULL)
 357     home_directory = ".";
 358   char *ttcn3_history_filename = mprintf("%s/%s", home_directory,
 359     TTCN3_HISTORY_FILENAME);
 360   // Read history from file, don't bother if it does not exist!
 361   read_history(ttcn3_history_filename);
 362   // Set our own command completion function
 363   rl_completion_entry_function = (Function*)completeCommand;
 364   // Override rl_getc() in order to detect shell mode
 365   rl_getc_function = getcWithShellDetection;
 366
 367   // TCP listen port parameter, returns TCP port on which it listens!
 368   // Returns 0 on error.
 369   if (MainController::start_session(mycfg.local_addr, mycfg.tcp_listen_port,
 370     mycfg.unix_sockets_enabled) == 0) {
 371     puts("Initialization of TCP server failed. Exiting.");
 372     Free(ttcn3_history_filename);
 373     return EXIT_FAILURE;
 374   }
 375
 376   do {
 377     char *line_read = readline(PROMPT);
 378     if (line_read != NULL) {
 379       shell_mode = FALSE;
 380       stripLWS(line_read);
 381       if (*line_read) {
 382         add_history(line_read); // history maintains its own copy
 383         // process and free line
 384         processCommand(line_read);
 385         free(line_read);
 386         line_read = NULL;
 387       }
 388     } else {
 389       // EOF was received
 390       puts("exit");
 391       exitCallback("");
 392     }
 393   } while (!exitFlag);
 394
 395   if (write_history(ttcn3_history_filename))
 396     perror("Could not save history.");
 397   Free(ttcn3_history_filename);
 398
 399   return EXIT_SUCCESS;
 400 }
 401
 402 int Cli::batchMode()
 403 {
 404   printf("Entering batch mode. Waiting for %d HC%s to connect...\n",
 405     mycfg.num_hcs, mycfg.num_hcs > 1 ? "s" : "");
 406   if (mycfg.execute_list_len <= 0) {
 407     puts("No [EXECUTE] section was given in the configuration file. "
 408       "Exiting.");
 409     return EXIT_FAILURE;
 410   }
 411   boolean error_flag = FALSE;
 412   // start to listen on TCP port
 413   if (MainController::start_session(mycfg.local_addr, mycfg.tcp_listen_port,
 414     mycfg.unix_sockets_enabled) == 0) {
 415     puts("Initialization of TCP server failed. Exiting.");
 416     return EXIT_FAILURE;
 417   }
 418   waitMCState(WAIT_HC_CONNECTED);
 419   // download config file
 420   MainController::configure(mycfg.config_read_buffer);
 421   waitMCState(WAIT_ACTIVE);
 422   if (MainController::get_state() != mctr::MC_ACTIVE) {
 423     puts("Error during initialization. Cannot continue in batch mode.");
 424     error_flag = TRUE;
 425   }
 426   if (!error_flag) {
 427     // create MTC on firstly connected HC
 428     MainController::create_mtc(0);
 429     waitMCState(WAIT_MTC_CREATED);
 430     if (MainController::get_state() != mctr::MC_READY) {
 431       puts("Creation of MTC failed. Cannot continue in batch mode.");
 432       error_flag = TRUE;
 433     }
 434   }
 435   if (!error_flag) {
 436     // execute each item of the list
 437     for (int i = 0; i < mycfg.execute_list_len; i++) {
 438       executeFromList(i);
 439       waitMCState(WAIT_MTC_READY);
 440       if (MainController::get_state() != mctr::MC_READY) {
 441         puts("MTC terminated unexpectedly. Cannot continue in batch "
 442           "mode.");
 443         error_flag = TRUE;
 444         break;
 445       }
 446     }
 447   }
 448   if (!error_flag) {
 449     // terminate the MTC
 450     MainController::exit_mtc();
 451     waitMCState(WAIT_MTC_TERMINATED);
 452   }
 453   // now MC must be in state MC_ACTIVE anyway
 454   // shutdown MC
 455   MainController::shutdown_session();
 456   waitMCState(WAIT_SHUTDOWN_COMPLETE);
 457   if (error_flag) return EXIT_FAILURE;
 458   else return EXIT_SUCCESS;
 459 }
 460
 461 //----------------------------------------------------------------------------
 462 // PRIVATE
 463
 464 void Cli::processCommand(char *line_read)
 465 {
 466   for (const Command *command = command_list; command->name != NULL;
 467        command++) {
 468     size_t command_name_len = strlen(command->name);
 469     if (!strncmp(line_read, command->name, command_name_len)) {
 470       memset(line_read, ' ', command_name_len);
 471       stripLWS(line_read);
 472       (this->*command->callback_function)(line_read);
 473       return;
 474     }
 475   }
 476   for (const DebugCommand* command = debug_command_list; command->name != NULL;
 477        command++) {
 478     size_t command_name_len = strlen(command->name);
 479     if (!strncmp(line_read, command->name, command_name_len)) {
 480       memset(line_read, ' ', command_name_len);
 481       stripLWS(line_read);
 482       MainController::debug_command(command->commandID, line_read);
 483       return;
 484     }
 485   }
 486   puts("Unknown command, try again...");
 487 }
 488
 489 //----------------------------------------------------------------------------
 490 // PRIVATE
 491 // Create Main Test Component
 492
 493 void Cli::cmtcCallback(const char *arguments)
 494 {
 495   int hostIndex;
 496   if(*arguments == 0) hostIndex = 0;
 497   else {
 498     hostIndex = getHostIndex(arguments);
 499     if (hostIndex < 0) return;
 500   }
 501   switch (MainController::get_state()) {
 502   case mctr::MC_LISTENING:
 503   case mctr::MC_LISTENING_CONFIGURED:
 504     puts("Waiting for HC to connect...");
 505     waitMCState(WAIT_HC_CONNECTED);
 506   case mctr::MC_HC_CONNECTED:
 507     MainController::configure(mycfg.config_read_buffer);
 508     waitMCState(WAIT_ACTIVE);
 509     if (MainController::get_state() != mctr::MC_ACTIVE) {
 510       puts("Error during initialization. Cannot create MTC.");
 511       break;
 512     }
 513   case mctr::MC_ACTIVE:
 514     MainController::create_mtc(hostIndex);
 515     waitMCState(WAIT_MTC_CREATED);
 516     break;
 517   default:
 518     puts("MTC already exists.");
 519   }
 520   fflush(stdout);
 521 }
 522
 523 //----------------------------------------------------------------------------
 524 // PRIVATE
 525 // Start Main Test Component and execute the
 526 // a) control part or testcase (or *) given in arguments
 527 // b) EXECUTE part of supplied configuration file -- if arguments==NULL
 528
 529 void Cli::smtcCallback(const char *arguments)
 530 {
 531   switch (MainController::get_state()) {
 532   case mctr::MC_LISTENING:
 533   case mctr::MC_LISTENING_CONFIGURED:
 534   case mctr::MC_HC_CONNECTED:
 535   case mctr::MC_ACTIVE:
 536     puts("MTC does not exist.");
 537     break;
 538   case mctr::MC_READY:
 539     if (*arguments == 0) {
 540       // Execute configuration file's execute section
 541       if (mycfg.execute_list_len > 0) {
 542         puts("Executing all items of [EXECUTE] section.");
 543         waitState = WAIT_EXECUTE_LIST;
 544         executeListIndex = 0;
 545         executeFromList(0);
 546       } else {
 547         puts("No [EXECUTE] section was given in the configuration "
 548           "file.");
 549       }
 550     } else { // Check the arguments
 551       size_t doti = 0, alen = strlen(arguments), state = 0;
 552       for (size_t r = 0; r < alen; r++) {
 553         switch (arguments[r]) {
 554         case '.':
 555           ++state;
 556           doti = r;
 557           break;
 558         case ' ':
 559         case '\t':
 560           state = 3;
 561         }
 562       }
 563
 564       if(state > 1) { // incorrect argument
 565         puts("Incorrect argument format.");
 566         helpCallback(SMTC_TEXT);
 567       } else {
 568         if(state == 0) { // only modulename is given in arguments
 569           MainController::execute_control(arguments);
 570         } else { // modulename.something in arguments
 571           expstring_t arg_copy = mcopystr(arguments);
 572           arg_copy[doti++] = '\0';
 573           if (!strcmp(arg_copy + doti, "*"))
 574             MainController::execute_testcase(arg_copy, NULL);
 575           else if (!strcmp(arg_copy + doti, "control"))
 576             MainController::execute_control(arg_copy);
 577           else MainController::execute_testcase(arg_copy,
 578             arg_copy + doti);
 579           Free(arg_copy);
 580         }
 581       }
 582     }
 583     break;
 584   default:
 585     puts("MTC is busy.");
 586   }
 587   fflush(stdout);
 588 }
 589
 590 //----------------------------------------------------------------------------
 591 // PRIVATE
 592 // Stops test execution
 593
 594 void Cli::stopCallback(const char *arguments)
 595 {
 596   if (*arguments == 0) {
 597     switch (MainController::get_state()) {
 598     case mctr::MC_TERMINATING_TESTCASE:
 599     case mctr::MC_EXECUTING_CONTROL:
 600     case mctr::MC_EXECUTING_TESTCASE:
 601     case mctr::MC_PAUSED:
 602       MainController::stop_execution();
 603       if (waitState == WAIT_EXECUTE_LIST) waitState = WAIT_NOTHING;
 604       break;
 605     default:
 606       puts("Tests are not running.");
 607     }
 608   } else helpCallback(STOP_TEXT);
 609 }
 610
 611 //----------------------------------------------------------------------------
 612 // PRIVATE
 613 // Sets whether to interrupt test execution after testcase
 614
 615 void Cli::pauseCallback(const char *arguments)
 616 {
 617   if (arguments[0] != '\0') {
 618     if (!strcmp(arguments, "on")) {
 619       if (!MainController::get_stop_after_testcase()) {
 620         MainController::stop_after_testcase(TRUE);
 621         puts("Pause function is enabled. "
 622           "Execution will stop at the end of each testcase.");
 623       } else puts("Pause function is already enabled.");
 624     } else if (!strcmp(arguments, "off")) {
 625       if (MainController::get_stop_after_testcase()) {
 626         MainController::stop_after_testcase(FALSE);
 627         puts("Pause function is disabled. "
 628           "Execution will continue at the end of each testcase.");
 629       } else puts("Pause function is already disabled.");
 630     } else helpCallback(PAUSE_TEXT);
 631   } else printf("Pause function is %s.\n",
 632     MainController::get_stop_after_testcase() ? "enabled" : "disabled");
 633 }
 634
 635 //----------------------------------------------------------------------------
 636 // PRIVATE
 637 // Resumes interrupted test execution
 638
 639 void Cli::continueCallback(const char *arguments)
 640 {
 641   if (*arguments == 0) {
 642     switch (MainController::get_state()) {
 643     case mctr::MC_TERMINATING_TESTCASE:
 644     case mctr::MC_EXECUTING_CONTROL:
 645     case mctr::MC_EXECUTING_TESTCASE:
 646       puts("Execution is not paused.");
 647       break;
 648     case mctr::MC_PAUSED:
 649       MainController::continue_testcase();
 650       break;
 651     default:
 652       puts("Tests are not running.");
 653     }
 654   } else helpCallback(CONTINUE_TEXT);
 655 }
 656
 657 //----------------------------------------------------------------------------
 658 // PRIVATE
 659 // Exit Main Test Component
 660
 661 void Cli::emtcCallback(const char *arguments)
 662 {
 663   if(*arguments == 0) {
 664     switch (MainController::get_state()) {
 665     case mctr::MC_LISTENING:
 666     case mctr::MC_LISTENING_CONFIGURED:
 667     case mctr::MC_HC_CONNECTED:
 668     case mctr::MC_ACTIVE:
 669       puts("MTC does not exist.");
 670       break;
 671     case mctr::MC_READY:
 672       MainController::exit_mtc();
 673       waitMCState(WAIT_MTC_TERMINATED);
 674       break;
 675     default:
 676       puts("MTC cannot be terminated.");
 677     }
 678   } else {
 679     helpCallback(EMTC_TEXT);
 680   }
 681 }
 682
 683 //----------------------------------------------------------------------------
 684 // PRIVATE
 685 // Controls console logging
 686
 687 void Cli::logCallback(const char *arguments)
 688 {
 689   if (arguments[0] != '\0') {
 690     if (!strcmp(arguments, "on")) {
 691       loggingEnabled = TRUE;
 692       puts("Console logging is enabled.");
 693     } else if (!strcmp(arguments, "off")) {
 694       loggingEnabled = FALSE;
 695       puts("Console logging is disabled.");
 696     } else helpCallback(LOG_TEXT);
 697   } else printf("Console logging is %s.\n",
 698     loggingEnabled ? "enabled" : "disabled");
 699 }
 700
 701 //----------------------------------------------------------------------------
 702 // PRIVATE
 703 // Print connection information
 704
 705 void Cli::infoCallback(const char *arguments)
 706 {
 707   if (*arguments == 0) printInfo();
 708   else helpCallback(INFO_TEXT);
 709 }
 710
 711 //----------------------------------------------------------------------------
 712 // PRIVATE
 713 // Reconfigure MC and HCs
 714
 715 void Cli::reconfCallback(const char *arguments)
 716 {
 717   if(*arguments == 0) { // reconf called without its optional argument
 718     puts("Reconfiguration of MC and HCs using original configuration "
 719       "data\n -- not supported, yet.");
 720   } else { // reconf called with config_file argument
 721     puts("Reconfiguration of MC and HCs using configuration file"
 722       "specified in\ncommand line argument -- not supported, yet.");
 723   }
 724 }
 725
 726 //----------------------------------------------------------------------------
 727 // PRIVATE
 728 // Print general help or help on command usage to console
 729
 730 void Cli::helpCallback(const char *arguments)
 731 {
 732   if (*arguments == 0) {
 733     puts("Help is available for the following commands:");
 734     for (const Command *command = command_list;
 735       command->name != NULL; command++) {
 736       printf(" %s", command->name);
 737     }
 738     for (const DebugCommand *command = debug_command_list;
 739          command->name != NULL; command++) {
 740       printf(" %s", command->name);
 741     }
 742     putchar('\n');
 743   } else {
 744     for (const Command *command = command_list;
 745       command->name != NULL; command++) {
 746       if (!strncmp(arguments, command->name,
 747         strlen(command->name))) {
 748         printf("%s usage: %s\n%s\n", command->name,
 749           command->synopsis,
 750           command->description);
 751         return;
 752       }
 753     }
 754     for (const DebugCommand *command = debug_command_list;
 755          command->name != NULL; command++) {
 756       if (!strncmp(arguments, command->name,
 757         strlen(command->name))) {
 758         printf("%s usage: %s\n%s\n", command->name,
 759           command->synopsis,
 760           command->description);
 761         return;
 762       }
 763     }
 764     printf("No help for %s.\n", arguments);
 765   }
 766 }
 767
 768 //----------------------------------------------------------------------------
 769 // PRIVATE
 770 // Pass command to shell
 771
 772 void Cli::shellCallback(const char *arguments)
 773 {
 774   if(system(arguments) == -1) {
 775     perror("Error executing command in subshell.");
 776   }
 777 }
 778
 779 //----------------------------------------------------------------------------
 780 // PRIVATE
 781 // User initiated MC termination, exits the program.
 782 // Save history into file and terminate CLI session.
 783
 784 void Cli::exitCallback(const char *arguments)
 785 {
 786   if (*arguments == 0) {
 787     switch (MainController::get_state()) {
 788     case mctr::MC_READY:
 789       MainController::exit_mtc();
 790       waitMCState(WAIT_MTC_TERMINATED);
 791     case mctr::MC_LISTENING:
 792     case mctr::MC_LISTENING_CONFIGURED:
 793     case mctr::MC_HC_CONNECTED:
 794     case mctr::MC_ACTIVE:
 795       MainController::shutdown_session();
 796       waitMCState(WAIT_SHUTDOWN_COMPLETE);
 797       exitFlag = TRUE;
 798       break;
 799     default:
 800       puts("Cannot exit until execution is finished.");
 801     }
 802   } else {
 803     helpCallback(EXIT_TEXT);
 804   }
 805 }
 806
 807 void Cli::executeBatchFile(const char* filename)
 808 {
 809   FILE* fp = fopen(filename, "r");
 810   if (fp == NULL) {
 811     printf("Failed to open file '%s' for reading.\n", filename);
 812     return;
 813   }
 814   else {
 815     printf("Executing batch file '%s'.\n", filename);
 816   }
 817   char line[1024];
 818   while (fgets(line, sizeof(line), fp) != NULL) {
 819     size_t len = strlen(line);
 820     if (line[len - 1] == '\n') {
 821       line[len - 1] = '\0';
 822       --len;
 823     }
 824     if (len != 0) {
 825       printf("%s\n", line);
 826       processCommand(line);
 827     }
 828   }
 829   if (!feof(fp)) {
 830     printf("Error occurred while reading batch file '%s' (error code: %d).\n",
 831       filename, ferror(fp));
 832   }
 833   fclose(fp);
 834 }
 835
 836 //----------------------------------------------------------------------------
 837 // PRIVATE
 838 // Command completion function implementation for readline() library.
 839 // Heavily uses the ``static Command command_list[]'' array!
 840
 841 char *Cli::completeCommand(const char *prefix, int state)
 842 {
 843   static int command_index;
 844   static int debug_command_index;
 845   static size_t prefix_len;
 846   const char *command_name;
 847
 848   if(shell_mode)
 849     return rl_filename_completion_function(prefix, state);
 850
 851   if(state == 0) {
 852     command_index = 0;
 853     debug_command_index = 0;
 854     prefix_len = strlen(prefix);
 855   }
 856
 857   while((command_name = command_list[command_index].name)) {
 858     ++command_index;
 859     if(strncmp(prefix, command_name, prefix_len) == 0) {
 860       // Must allocate buffer for returned string (readline frees it)
 861       return strdup(command_name);
 862     }
 863   }
 864
 865   while ((command_name = debug_command_list[debug_command_index].name)) {
 866     ++debug_command_index;
 867     if (strncmp(prefix, command_name, prefix_len) == 0) {
 868       // Must allocate buffer for returned string (readline frees it)
 869       return strdup(command_name);
 870     }
 871   }
 872   // No match found
 873   return NULL;
 874 }
 875
 876 //----------------------------------------------------------------------------
 877 // PRIVATE
 878 // Character input function implementation for readline() library.
 879
 880 int Cli::getcWithShellDetection(FILE *fp)
 881 {
 882   int input_char = getc(fp);
 883   if(input_char == SHELL_ESCAPE)
 884     shell_mode = TRUE;
 885   return input_char;
 886 }
 887
 888
 889 //----------------------------------------------------------------------------
 890 // PRIVATE
 891
 892 void Cli::stripLWS(char *input_text)
 893 {
 894   if(input_text == NULL) {
 895     puts("stripLWS() called with NULL.");
 896     exit(EXIT_FAILURE); // This shall never happen
 897   }
 898   size_t head_index, tail_index, input_len = strlen(input_text);
 899   if(input_len < 1) return;
 900   for(head_index = 0; isspace(input_text[head_index]); head_index++) ;
 901   for(tail_index = input_len - 1; tail_index >= head_index &&
 902   isspace(input_text[tail_index]); tail_index--) ;
 903   size_t output_len = tail_index - head_index + 1;
 904   memmove(input_text, input_text + head_index, output_len);
 905   memset(input_text + output_len, 0, input_len - output_len);
 906 }
 907
 908 const char *Cli::verdict2str(verdicttype verdict)
 909 {
 910   switch (verdict) {
 911   case NONE:
 912     return "none";
 913   case PASS:
 914     return "pass";
 915   case INCONC:
 916     return "inconc";
 917   case FAIL:
 918     return "fail";
 919   case ERROR:
 920     return "error";
 921   default:
 922     return "unknown";
 923   }
 924 }
 925
 926 //----------------------------------------------------------------------------
 927 // PRIVATE
 928
 929 void Cli::printInfo()
 930 {
 931   puts("MC information:");
 932   printf(" MC state: %s\n",
 933     MainController::get_mc_state_name(MainController::get_state()));
 934   puts(" host information:");
 935   int host_index = 0;
 936   for ( ; ; host_index++) {
 937     mctr::host_struct *host = MainController::get_host_data(host_index);
 938     if (host != NULL) {
 939       printf("  - %s", host->hostname);
 940       const char *ip_addr = host->ip_addr->get_addr_str();
 941       // if the hostname differs from the IP address
 942       // (i.e. the host has a DNS entry)
 943       if (strcmp(ip_addr, host->hostname)) printf(" [%s]", ip_addr);
 944       // if the local hostname differs from the prefix of the DNS name
 945       if (strncmp(host->hostname, host->hostname_local,
 946         strlen(host->hostname_local)))
 947         printf(" (%s)", host->hostname_local);
 948       puts(":");
 949       printf("     operating system: %s %s on %s\n", host->system_name,
 950         host->system_release, host->machine_type);
 951       printf("     HC state: %s\n",
 952         MainController::get_hc_state_name(host->hc_state));
 953
 954       puts("     test component information:");
 955       // make a copy of the array containing component references
 956       int n_components = host->n_components;
 957       component *components = (component*)Malloc(n_components *
 958         sizeof(component));
 959       memcpy(components, host->components, n_components *
 960         sizeof(component));
 961       // the host structure has to be released in order to get access
 962       // to the component structures
 963       MainController::release_data();
 964       for (int component_index = 0; component_index < n_components;
 965         component_index++) {
 966         mctr::component_struct *comp = MainController::
 967           get_component_data(components[component_index]);
 968         // if the component has a name
 969         if (comp->comp_name != NULL)
 970           printf("      - name: %s, component reference: %d\n",
 971             comp->comp_name, comp->comp_ref);
 972         else printf("      - component reference: %d\n",
 973           comp->comp_ref);
 974         if (comp->comp_type.definition_name != NULL) {
 975           printf("         component type: ");
 976           if (comp->comp_type.module_name != NULL)
 977             printf("%s.", comp->comp_type.module_name);
 978           printf("%s\n", comp->comp_type.definition_name);
 979         }
 980         printf("         state: %s\n",
 981           MainController::get_tc_state_name(comp->tc_state));
 982         if (comp->tc_fn_name.definition_name != NULL) {
 983           printf("         executed %s: ",
 984             comp->comp_ref == MTC_COMPREF ?
 985               "test case" : "function");
 986           if (comp->tc_fn_name.module_name != NULL)
 987             printf("%s.", comp->tc_fn_name.module_name);
 988           printf("%s\n", comp->tc_fn_name.definition_name);
 989         }
 990         if (comp->tc_state == mctr::TC_EXITING ||
 991           comp->tc_state == mctr::TC_EXITED)
 992           printf("         local verdict: %s\n",
 993             verdict2str(comp->local_verdict));
 994         MainController::release_data();
 995       }
 996       if (n_components == 0) puts("      no components on this host");
 997       Free(components);
 998     } else {
 999       MainController::release_data();
1000       break;
1001     }
1002   }
1003   if (host_index == 0) puts("  no HCs are connected");
1004   printf(" pause function: %s\n", MainController::get_stop_after_testcase() ?
1005     "enabled" : "disabled");
1006   printf(" console logging: %s\n", loggingEnabled ?
1007     "enabled" : "disabled");
1008   fflush(stdout);
1009 }
1010
1011 //----------------------------------------------------------------------------
1012 // PRIVATE
1013
1014 void Cli::lock()
1015 {
1016   if (pthread_mutex_lock(&mutex)) {
1017     perror("Cli::lock: pthread_mutex_lock failed.");
1018     exit(EXIT_FAILURE);
1019   }
1020 }
1021
1022 void Cli::unlock()
1023 {
1024   if (pthread_mutex_unlock(&mutex)) {
1025     perror("Cli::unlock: pthread_mutex_unlock failed.");
1026     exit(EXIT_FAILURE);
1027   }
1028 }
1029
1030 void Cli::wait()
1031 {
1032   if (pthread_cond_wait(&cond, &mutex)) {
1033     perror("Cli::wait: pthread_cond_wait failed.");
1034     exit(EXIT_FAILURE);
1035   }
1036 }
1037
1038 void Cli::signal()
1039 {
1040   if (pthread_cond_signal(&cond)) {
1041     perror("Cli::signal: pthread_cond_signal failed.");
1042     exit(EXIT_FAILURE);
1043   }
1044 }
1045
1046 void Cli::waitMCState(waitStateEnum newWaitState)
1047 {
1048   lock();
1049   if (newWaitState != WAIT_NOTHING) {
1050     if (conditionHolds(newWaitState)) {
1051       waitState = WAIT_NOTHING;
1052     } else {
1053       waitState = newWaitState;
1054       wait();
1055     }
1056   } else {
1057     fputs("Cli::waitMCState: invalid argument", stderr);
1058     exit(EXIT_FAILURE);
1059   }
1060   unlock();
1061 }
1062
1063 boolean Cli::conditionHolds(waitStateEnum askedState)
1064 {
1065   switch (askedState) {
1066   case WAIT_HC_CONNECTED:
1067     if (MainController::get_state() == mctr::MC_HC_CONNECTED) {
1068       if (mycfg.num_hcs > 0) {
1069         return MainController::get_nof_hosts() >= mycfg.num_hcs;
1070       }
1071       else return TRUE;
1072     } else return FALSE;
1073   case WAIT_ACTIVE:
1074     switch (MainController::get_state()) {
1075     case mctr::MC_ACTIVE: // normal case
1076     case mctr::MC_HC_CONNECTED: // error happened with config file
1077     case mctr::MC_LISTENING: // even more strange situations
1078       return TRUE;
1079     default:
1080       return FALSE;
1081     }
1082     case WAIT_MTC_CREATED:
1083     case WAIT_MTC_READY:
1084       switch (MainController::get_state()) {
1085       case mctr::MC_READY: // normal case
1086       case mctr::MC_ACTIVE: // MTC crashed unexpectedly
1087       case mctr::MC_LISTENING_CONFIGURED: // MTC and all HCs are crashed
1088         // at the same time
1089       case mctr::MC_HC_CONNECTED: // even more strange situations
1090         return TRUE;
1091       default:
1092         return FALSE;
1093       }
1094       case WAIT_MTC_TERMINATED:
1095         return MainController::get_state() == mctr::MC_ACTIVE;
1096       case WAIT_SHUTDOWN_COMPLETE:
1097         return MainController::get_state() == mctr::MC_INACTIVE;
1098       case WAIT_EXECUTE_LIST:
1099         if (MainController::get_state() == mctr::MC_READY) {
1100           if (++executeListIndex < mycfg.execute_list_len) {
1101             unlock();
1102             executeFromList(executeListIndex);
1103             lock();
1104           } else {
1105             puts("Execution of [EXECUTE] section finished.");
1106             waitState = WAIT_NOTHING;
1107           }
1108         }
1109         return FALSE;
1110       default:
1111         return FALSE;
1112   }
1113 }
1114
1115 int Cli::getHostIndex(const char* hostname)
1116 {
1117   int hostname_len = strlen(hostname);
1118   int index, found = -1;
1119   for (index = 0; ; index++) {
1120     const mctr::host_struct *host =
1121       MainController::get_host_data(index);
1122     if (host != NULL) {
1123       if (!strncmp(host->hostname, hostname, hostname_len) ||
1124         !strncmp(host->hostname_local, hostname, hostname_len)) {
1125         MainController::release_data();
1126         if (found == -1) found = index;
1127         else {
1128           printf("Hostname %s is ambiguous.\n", hostname);
1129           found = -1;
1130           break;
1131         }
1132       } else MainController::release_data();
1133     } else {
1134       MainController::release_data();
1135       if (found == -1) printf("No such host: %s.\n", hostname);
1136       break;
1137     }
1138   }
1139   return found;
1140 }
1141
1142 void Cli::executeFromList(int index)
1143 {
1144   if (index >= mycfg.execute_list_len) {
1145     fputs("Cli::executeFromList: invalid argument", stderr);
1146     exit(EXIT_FAILURE);
1147   }
1148   if (mycfg.execute_list[index].testcase_name == NULL) {
1149     MainController::execute_control(mycfg.execute_list[index].module_name);
1150   } else if (!strcmp(mycfg.execute_list[index].testcase_name, "*")) {
1151     MainController::execute_testcase(mycfg.execute_list[index].module_name,
1152       NULL);
1153   } else {
1154     MainController::execute_testcase(mycfg.execute_list[index].module_name,
1155       mycfg.execute_list[index].testcase_name);
1156   }
1157 }
1158
1159 //----------------------------------------------------------------------------
1160 // Local Variables:
1161 // mode: C++
1162 // indent-tabs-mode: nil
1163 // c-basic-offset: 2
1164 // End:
1165
1166 extern boolean error_flag; // in config_read.y
1167 extern std::string get_cfg_read_current_file(); // in config_read.y
1168 extern int config_read_lineno; // in config_read.l
1169 extern char *config_read_text; // in config_read.l
1170
1171 void config_read_warning(const char *warning_str, ...)
1172 {
1173     fprintf(stderr, "Warning: in configuration file `%s', line %d: ",
1174             get_cfg_read_current_file().c_str(), config_read_lineno);
1175     va_list pvar;
1176     va_start(pvar, warning_str);
1177     vfprintf(stderr, warning_str, pvar);
1178     va_end(pvar);
1179     putc('\n', stderr);
1180 }
1181
1182 void config_read_error(const char *error_str, ...)
1183 {
1184     fprintf(stderr, "Parse error in configuration file `%s': in line %d, "
1185             "at or before token `%s': ",
1186             get_cfg_read_current_file().c_str(), config_read_lineno, config_read_text);
1187     va_list pvar;
1188     va_start(pvar, error_str);
1189     vfprintf(stderr, error_str, pvar);
1190     va_end(pvar);
1191     putc('\n', stderr);
1192     error_flag = TRUE;
1193 }
1194
1195 void config_preproc_error(const char *error_str, ...)
1196 {
1197     fprintf(stderr, "Parse error while pre-processing configuration file "
1198             "`%s': in line %d: ",
1199             get_cfg_preproc_current_file().c_str(),
1200             config_preproc_yylineno);
1201     va_list pvar;
1202     va_start(pvar, error_str);
1203     vfprintf(stderr, error_str, pvar);
1204     va_end(pvar);
1205     putc('\n', stderr);
1206     error_flag = TRUE;
1207 }
1208
1209 // called by functions in path.c
1210 void path_error(const char *fmt, ...)
1211 {
1212   fprintf(stderr, "File error: ");
1213   va_list parameters;
1214   va_start(parameters, fmt);
1215   vfprintf(stderr, fmt, parameters);
1216   va_end(parameters);
1217   putc('\n', stderr);
1218 }