void LineCallback(asIScriptContext *ctx) { if( ctx->GetState() == asEXECUTION_ACTIVE ) { // Call the command for listing local variables InterpretCommand("l v", ctx); // Call the command for listing global variables InterpretCommand("l g", ctx); // Invoke the original line callback CDebugger::LineCallback(ctx); } }
//++ ------------------------------------------------------------------------------------ // Details: Execute commands from command source file in specified mode, and // set exit-flag if needed. // Type: Method. // Args: vbAsyncMode - (R) True = execute commands in asynchronous mode, false = otherwise. // Return: MIstatus::success - Function succeeded. // MIstatus::failure - Function failed. // Throws: None. //-- bool CMIDriver::ExecuteCommandFile(const bool vbAsyncMode) { std::ifstream ifsStartScript(m_strCmdLineArgCommandFileNamePath.c_str()); if (!ifsStartScript.is_open()) { const CMIUtilString errMsg( CMIUtilString::Format(MIRSRC(IDS_UTIL_FILE_ERR_OPENING_FILE_UNKNOWN), m_strCmdLineArgCommandFileNamePath.c_str())); SetErrorDescription(errMsg.c_str()); const bool bForceExit = true; SetExitApplicationFlag(bForceExit); return MIstatus::failure; } // Switch lldb to synchronous mode CMICmnLLDBDebugSessionInfo &rSessionInfo(CMICmnLLDBDebugSessionInfo::Instance()); const bool bAsyncSetting = rSessionInfo.GetDebugger().GetAsync(); rSessionInfo.GetDebugger().SetAsync(vbAsyncMode); // Execute commands from file bool bOk = MIstatus::success; CMIUtilString strCommand; while (!m_bExitApp && std::getline(ifsStartScript, strCommand)) { // Print command bOk = CMICmnStreamStdout::TextToStdout(strCommand); // Skip if it's a comment or empty line if (strCommand.empty() || strCommand[0] == '#') continue; // Execute if no error if (bOk) { CMIUtilThreadLock lock(rSessionInfo.GetSessionMutex()); bOk = InterpretCommand(strCommand); } // Draw the prompt after command will be executed (if enabled) bOk = bOk && CMICmnStreamStdout::WritePrompt(); // Exit if there is an error if (!bOk) { const bool bForceExit = true; SetExitApplicationFlag(bForceExit); break; } // Wait while the handler thread handles incoming events CMICmnLLDBDebugger::Instance().WaitForHandleEvent(); } // Switch lldb back to initial mode rSessionInfo.GetDebugger().SetAsync(bAsyncSetting); return bOk; }
//++ ------------------------------------------------------------------------------------ // Details: Execute commands (by injecting them into the stdin line queue container) and // other code to set up the MI Driver such that is can take the executable // argument passed on the command and create a debug session for it. // Type: Method. // Args: None. // Return: MIstatus::success - Functionality succeeded. // MIstatus::failure - Functionality failed. // Throws: None. //-- bool CMIDriver::LocalDebugSessionStartupExecuteCommands(void) { const CMIUtilString strCmd(CMIUtilString::Format("-file-exec-and-symbols \"%s\"", m_strCmdLineArgExecuteableFileNamePath.AddSlashes().c_str())); bool bOk = CMICmnStreamStdout::TextToStdout(strCmd); bOk = bOk && InterpretCommand(strCmd); bOk = bOk && CMICmnStreamStdout::WritePrompt(); return bOk; }
void MenuExecuteCommand(MenuInstanceData* menu_data, const string& command) { MenuRec menu; if (menu_data->LoadMenuRecord(command, &menu)) { LogUserFunction(menu_data, command, &menu); InterpretCommand(menu_data, menu.szExecute); } else { LogUserFunction(menu_data, command, &menu); } }
//++ ------------------------------------------------------------------------------------ // Details: *this driver sits and waits for input to the stdin line queue shared by *this // driver and the stdin monitor thread, it queues, *this reads, interprets and // reacts. // This function is used by the application's main thread. // Type: Method. // Args: None. // Return: MIstatus::success - Functional succeeded. // MIstatus::failure - Functional failed. // Throws: None. //-- bool CMIDriver::ReadStdinLineQueue( void ) { // True when queue contains input bool bHaveInput = false; // Stores the current input line CMIUtilString lineText; { // Lock while we access the queue CMIUtilThreadLock lock( m_threadMutex ); if( !m_queueStdinLine.empty() ) { lineText = m_queueStdinLine.front(); m_queueStdinLine.pop(); bHaveInput = !lineText.empty(); } } // Process while we have input if( bHaveInput ) { if( lineText == "quit" ) { // We want to be exiting when receiving a quit command m_bExitApp = true; return MIstatus::success; } // Process the command const bool bOk = InterpretCommand( lineText ); // Draw prompt if desired if( bOk && m_rStdin.GetEnablePrompt() ) m_rStdOut.WriteMIResponse( m_rStdin.GetPrompt() ); // Input has been processed bHaveInput = false; } else { // Give resources back to the OS const std::chrono::milliseconds time( 1 ); std::this_thread::sleep_for( time ); } return MIstatus::success; }
bool MenuInstanceData::Open() { Close(); // Open up the main data file unique_ptr<File> menu_file(new File(create_menu_filename("mnu"))); if (!menu_file->Open(File::modeBinary | File::modeReadOnly, File::shareDenyNone)) { // Unable to open menu MenuSysopLog("Unable to open Menu"); return false; } // Read the header (control) record into memory menu_file->Seek(0L, File::seekBegin); menu_file->Read(&header, sizeof(MenuHeader)); // Version numbers can be checked here. if (!CreateMenuMap(menu_file.get())) { MenuSysopLog("Unable to create menu index."); return false; } if (!CheckMenuSecurity(&header, true)) { MenuSysopLog("< Menu Sec"); return false; } // Open/Rease/Close Prompt file. We use binary mode since we want the // \r to remain on windows (and linux). TextFile prompt_file(create_menu_filename("pro"), "rb"); if (prompt_file.IsOpen()) { string tmp = prompt_file.ReadFileIntoString(); string::size_type end = tmp.find(".end."); if (end != string::npos) { prompt = tmp.substr(0, end); } else { prompt = tmp; } } // Execute command to use on entering the menu (if any). if (header.szScript[0]) { InterpretCommand(this, header.szScript); } return true; }
//++ ------------------------------------------------------------------------------------ // Details: Set the MI Driver's exit application flag. The application checks this flag // after every stdin line is read so the exit may not be instantaneous. // If vbForceExit is false the MI Driver queries its state and determines if is // should exit or continue operating depending on that running state. // This is related to the running state of the MI driver. // Type: Overridden. // Args: None. // Return: None. // Throws: None. //-- void CMIDriver::SetExitApplicationFlag(const bool vbForceExit) { if (vbForceExit) { CMIUtilThreadLock lock(m_threadMutex); m_bExitApp = true; return; } // CODETAG_DEBUG_SESSION_RUNNING_PROG_RECEIVED_SIGINT_PAUSE_PROGRAM // Did we receive a SIGINT from the client during a running debug program, if // so then SIGINT is not to be taken as meaning kill the MI driver application // but halt the inferior program being debugged instead if (m_eCurrentDriverState == eDriverState_RunningDebugging) { InterpretCommand("-exec-interrupt"); return; } m_bExitApp = true; }
void TakeCommands(asIScriptContext *ctx) { // Simulate the user stepping through the execution InterpretCommand("s", ctx); }
//++ ------------------------------------------------------------------------------------ // Details: Call this function puts *this driver to work. // This function is used by the application's main thread. // Type: Overridden. // Args: None. // Return: MIstatus::success - Functional succeeded. // MIstatus::failure - Functional failed. // Throws: None. //-- bool CMIDriver::DoMainLoop(void) { if (!InitClientIDEToMIDriver()) // Init Eclipse IDE { SetErrorDescriptionn(MIRSRC(IDS_MI_INIT_ERR_CLIENT_USING_DRIVER)); return MIstatus::failure; } if (!StartWorkerThreads()) return MIstatus::failure; bool bOk = MIstatus::success; if (HaveExecutableFileNamePathOnCmdLine()) { if (!LocalDebugSessionStartupExecuteCommands()) { SetErrorDescription(MIRSRC(IDS_MI_INIT_ERR_LOCAL_DEBUG_SESSION)); bOk = MIstatus::failure; } } // App is not quitting currently m_bExitApp = false; // Handle source file if (m_bHaveCommandFileNamePathOnCmdLine) { const bool bAsyncMode = false; ExecuteCommandFile(bAsyncMode); } // While the app is active while (bOk && !m_bExitApp) { CMIUtilString errorText; const char *pCmd = m_rStdin.ReadLine (errorText); if (pCmd != nullptr) { CMIUtilString lineText(pCmd); if (!lineText.empty ()) { // Check that the handler thread is alive (otherwise we stuck here) assert(CMICmnLLDBDebugger::Instance().ThreadIsActive()); { // Lock Mutex before processing commands so that we don't disturb an event // being processed CMIUtilThreadLock lock(CMICmnLLDBDebugSessionInfo::Instance().GetSessionMutex()); bOk = InterpretCommand(lineText); } // Draw prompt if desired bOk = bOk && CMICmnStreamStdout::WritePrompt(); // Wait while the handler thread handles incoming events CMICmnLLDBDebugger::Instance().WaitForHandleEvent(); } } } // Signal that the application is shutting down DoAppQuit(); // Close and wait for the workers to stop StopWorkerThreads(); // Ensure that a new line is sent as the last act of the dying driver m_rStdOut.WriteMIResponse("\n", false); return MIstatus::success; }
//++ ------------------------------------------------------------------------------------ // Details: Gets called when lldb-mi gets a signal. Stops the process if it was SIGINT. // // Type: Method. // Args: signal that was delivered // Return: None. // Throws: None. //-- void CMIDriver::DeliverSignal(int signal) { if (signal == SIGINT && (m_eCurrentDriverState == eDriverState_RunningDebugging)) InterpretCommand("-exec-interrupt"); }
int _cdecl main(int argc, char *argv[]) { SC_HANDLE hSCManager = NULL; SC_HANDLE hService = NULL; SERVICE_STATUS_PROCESS serviceInfo; DWORD bytesNeeded; HANDLE hDevice = NULL; BOOL bResult; DWORD result; ULONG threadId; HANDLE thread = NULL; LOG_CONTEXT context; INT inputChar; // // Initialize handle in case of error // context.ShutDown = NULL; context.VerbosityFlags = 0; // // Start the kernel mode driver through the service manager // hSCManager = OpenSCManager (NULL, NULL, SC_MANAGER_ALL_ACCESS) ; if (NULL == hSCManager) { result = GetLastError(); printf("ERROR opening Service Manager...\n"); DisplayError( result ); goto Main_Continue; } hService = OpenService( hSCManager, FILESPY_SERVICE_NAME, FILESPY_SERVICE_ACCESS); if (NULL == hService) { result = GetLastError(); printf("ERROR opening FileSpy Service...\n"); DisplayError( result ); goto Main_Continue; } if (!QueryServiceStatusEx( hService, SC_STATUS_PROCESS_INFO, (UCHAR *)&serviceInfo, sizeof(serviceInfo), &bytesNeeded)) { result = GetLastError(); printf("ERROR querrying status of FileSpy Service...\n"); DisplayError( result ); goto Main_Continue; } if(serviceInfo.dwCurrentState != SERVICE_RUNNING) { // // Service hasn't been started yet, so try to start service // if (!StartService(hService, 0, NULL)) { result = GetLastError(); printf("ERROR starting FileSpy service...\n"); DisplayError( result ); goto Main_Continue; } } Main_Continue: printf("Hit [Enter] to begin command mode...\n"); // // Open the device that is used to talk to FileSpy. // printf("FileSpy: Opening device...\n"); hDevice = CreateFile( FILESPY_W32_DEVICE_NAME, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if (hDevice == INVALID_HANDLE_VALUE) { result = GetLastError(); printf("ERROR opening device...\n"); DisplayError( result ); goto Main_Exit; } // // Initialize the fields of the LOG_CONTEXT. // context.Device = hDevice; context.ShutDown = CreateSemaphore( NULL, 0, 1, L"FileSpy shutdown"); if (context.ShutDown == NULL) { // // Insufficient memory for this semaphore, so shutdown. // printf( "ERROR insufficient memory\n" ); goto Main_Exit; } context.CleaningUp = FALSE; context.LogToScreen = context.NextLogToScreen = TRUE; context.LogToFile = FALSE; context.OutputFile = NULL; // // Check the valid parameters for startup // if (argc > 1) { if (InterpretCommand(argc - 1, &(argv[1]), &context) == USAGE_ERROR) { goto Main_Exit; } } // // Propagate the /s switch to the variable that the logging // thread checks. // context.LogToScreen = context.NextLogToScreen; // // Check to see what devices we are attached to from // previous runs of this program. // bResult = ListDevices(&context); if (!bResult) { result = GetLastError(); printf("ERROR listing devices...\n"); DisplayError( result ); } // // Create the thread to read the log records that are gathered // by filespy.sys. // printf("FileSpy: Creating logging thread...\n"); thread = CreateThread( NULL, 0, RetrieveLogRecords, (LPVOID)&context, 0, &threadId); if (!thread) { result = GetLastError(); printf("ERROR creating logging thread...\n"); DisplayError( result ); goto Main_Exit; } while (inputChar = getchar()) { CHAR commandLine[81]; INT parmCount, count, ch; CHAR **parms; BOOLEAN newParm; DWORD returnValue = SUCCESS; if (inputChar == '\n') { // // Start command interpreter. First we must turn off logging // to screen if we are. Also, remember the state of logging // to the screen, so that we can reinstate that when command // interpreter is finished. // context.NextLogToScreen = context.LogToScreen; context.LogToScreen = FALSE; while (returnValue != EXIT_INTERPRETER) { // // Print prompt // printf(">"); // // Read in next line, keeping track of the number of parameters // as you go // parmCount = 1; for (count = 0; (count < 80) && ((ch = getchar())!= '\n'); count++) { commandLine[count] = (CHAR)ch; if (ch == ' ') { parmCount ++; } } commandLine[count] = '\0'; parms = (CHAR **)malloc(parmCount * sizeof(CHAR *)); parmCount = 0; newParm = TRUE; for (count = 0; commandLine[count] != '\0'; count++) { if (newParm) { parms[parmCount] = &(commandLine[count]); parmCount ++; } if (commandLine[count] == ' ' ) { newParm = TRUE; } else { newParm = FALSE; } } // // We've got our parameter count and parameter list, so // send it off to be interpreted. // returnValue = InterpretCommand(parmCount, parms, &context); free(parms); if (returnValue == EXIT_PROGRAM) { // Time to stop the program goto Main_Cleanup; } } // Set LogToScreen appropriately based on any commands seen context.LogToScreen = context.NextLogToScreen; if (context.LogToScreen) { printf("Should be logging to screen...\n"); } } } Main_Cleanup: // // Clean up the threads, then fall through to Main_Exit // printf("FileSpy: Cleaning up...\n"); // // Set the Cleaning up flag to TRUE to notify other threads // that we are cleaning up // context.CleaningUp = TRUE; // // Wait for everyone to shut down // WaitForSingleObject(context.ShutDown, INFINITE); if (context.LogToFile) { fclose(context.OutputFile); } Main_Exit: // // Clean up the data that is always around and exit // if(context.ShutDown) { CloseHandle(context.ShutDown); } if (thread) { CloseHandle(thread); } if(hSCManager) { CloseServiceHandle(hSCManager); } if(hService) { CloseServiceHandle(hService); } if (hDevice) { CloseHandle(hDevice); } printf("FileSpy: All done\n"); return 0; }
//++ ------------------------------------------------------------------------------------ // Details: Call this function puts *this driver to work. // This function is used by the application's main thread. // Type: Overridden. // Args: None. // Return: MIstatus::success - Functional succeeded. // MIstatus::failure - Functional failed. // Throws: None. //-- bool CMIDriver::DoMainLoop(void) { if (!InitClientIDEToMIDriver()) // Init Eclipse IDE { SetErrorDescriptionn(MIRSRC(IDS_MI_INIT_ERR_CLIENT_USING_DRIVER)); return MIstatus::failure; } if (!StartWorkerThreads()) return MIstatus::failure; bool bOk = MIstatus::success; if (HaveExecutableFileNamePathOnCmdLine()) { if (!LocalDebugSessionStartupExecuteCommands()) { SetErrorDescription(MIRSRC(IDS_MI_INIT_ERR_LOCAL_DEBUG_SESSION)); bOk = MIstatus::failure; } } // App is not quitting currently m_bExitApp = false; // While the app is active while (bOk && !m_bExitApp) { CMIUtilString errorText; const MIchar *pCmd = m_rStdin.ReadLine (errorText); if (pCmd != nullptr) { CMIUtilString lineText(pCmd); if (!lineText.empty ()) { if (lineText == "quit") { // We want to be exiting when receiving a quit command m_bExitApp = true; break; } { // Lock Mutex before processing commands so that we don't disturb an event // being processed CMIUtilThreadLock lock(CMICmnLLDBDebugSessionInfo::Instance().GetSessionMutex()); bOk = InterpretCommand(lineText); } // Draw prompt if desired if (bOk && m_rStdin.GetEnablePrompt()) bOk = m_rStdOut.WriteMIResponse(m_rStdin.GetPrompt()); } } } // Signal that the application is shutting down DoAppQuit(); // Close and wait for the workers to stop StopWorkerThreads(); // Ensure that a new line is sent as the last act of the dying driver m_rStdOut.WriteMIResponse("\n", false); return MIstatus::success; }
void InterpretCommand(MenuInstanceData * pMenuData, const char *pszScript) { char szCmd[31], szParam1[51], szParam2[51]; char szTempScript[ 255 ]; memset(szTempScript, 0, sizeof(szTempScript)); strncpy(szTempScript, pszScript, 250); if (pszScript[0] == 0) { return; } char* pszScriptPointer = szTempScript; while (pszScriptPointer && !hangup) { pszScriptPointer = MenuParseLine(pszScriptPointer, szCmd, szParam1, szParam2); if (szCmd[0] == 0) { // || !pszScriptPointer || !*pszScriptPointer break; } // ------------------------- // Run a new menu instance int nCmdID = GetMenuIndex(szCmd); switch (nCmdID) { case 0: { // "MENU" // Spawn a new menu MenuInstanceData *pNewMenuData = static_cast<MenuInstanceData *>(malloc(sizeof(MenuInstanceData))); memset(pNewMenuData, 0, sizeof(MenuInstanceData)); pNewMenuData->nFinished = 0; pNewMenuData->nReload = 0; Menus(pNewMenuData, pMenuData->szPath, szParam1); free(pNewMenuData); } break; case 1: { // ------------------------- // Exit out of this instance // of the menu // ------------------------- // "ReturnFromMenu" InterpretCommand(pMenuData, pMenuData->header.szExitScript); pMenuData->nFinished = 1; } break; case 2: { // "EditMenuSet" EditMenus(); // flag if we are editing this menu pMenuData->nFinished = 1; pMenuData->nReload = 1; } break; case 3: { // "DLFreeFile" align(szParam2); MenuDownload(szParam1, szParam2, true, true); } break; case 4: { // "DLFile" align(szParam2); MenuDownload(szParam1, szParam2, false, true); } break; case 5: { // "RunDoor" MenuRunDoorName(szParam1, false); } break; case 6: { // "RunDoorFree" MenuRunDoorName(szParam1, true); } break; case 7: { // "RunDoorNumber" int nTemp = atoi(szParam1); MenuRunDoorNumber(nTemp, false); } break; case 8: { // "RunDoorNumberFree" int nTemp = atoi(szParam1); MenuRunDoorNumber(nTemp, true); } break; case 9: { // "PrintFile" printfile(szParam1, true); } break; case 10: { // "PrintFileNA" printfile(szParam1, false); } break; case 11: { // "SetSubNumber" SetSubNumber(szParam1); } break; case 12: { // "SetDirNumber" SetDirNumber(szParam1); } break; case 13: { // "SetMsgConf" SetMsgConf(szParam1[0]); } break; case 14: { // "SetDirConf" SetDirConf(szParam1[0]); } break; case 15: { // "EnableConf" EnableConf(); } break; case 16: { // "DisableConf" DisableConf(); } break; case 17: { // "Pause" pausescr(); } break; case 18: { // "ConfigUserMenuSet" ConfigUserMenuSet(); pMenuData->nFinished = 1; pMenuData->nReload = 1; } break; case 19: { // "DisplayHelp" if (GetSession()->GetCurrentUser()->IsExpert()) { AMDisplayHelp(pMenuData); } } break; case 20: { // "SelectSub" ChangeSubNumber(); } break; case 21: { // "SelectDir" ChangeDirNumber(); } break; case 22: { // "SubList" SubList(); } break; case 23: { // "UpSubConf" UpSubConf(); } break; case 24: { // "DownSubConf" DownSubConf(); } break; case 25: { // "UpSub" UpSub(); } break; case 26: { // "DownSub" DownSub(); } break; case 27: { // "ValidateUser" ValidateUser(); } break; case 28: { // "Doors" Chains(); } break; case 29: { // "TimeBank" TimeBank(); } break; case 30: { // "AutoMessage" AutoMessage(); } break; case 31: { // "BBSList" BBSList(); } break; case 32: { // "RequestChat" RequestChat(); } break; case 33: { // "Defaults" Defaults(pMenuData); } break; case 34: { // "SendEMail" SendEMail(); } break; case 35: { // "Feedback" FeedBack(); } break; case 36: { // "Bulletins" Bulletins(); } break; case 37: { // "HopSub" HopSub(); } break; case 38: { // "SystemInfo" SystemInfo(); } break; case 39: { // "JumpSubConf" JumpSubConf(); } break; case 40: { // "KillEMail" KillEMail(); } break; case 41: { // "LastCallers" LastCallers(); } break; case 42: { // "ReadEMail" ReadEMail(); } break; case 43: { // "NewMessageScan" NewMessageScan(); } break; case 44: { // "Goodbye" GoodBye(); } break; case 45: { // "PostMessage" WWIV_PostMessage(); } break; case 46: { // "NewMsgScanCurSub" ScanSub(); } break; case 47: { // "RemovePost" RemovePost(); } break; case 48: { // "TitleScan" TitleScan(); } break; case 49: { // "ListUsers" ListUsers(); } break; case 50: { // "Vote" Vote(); } break; case 51: { // "ToggleExpert" ToggleExpert(); } break; case 52: { // "YourInfo" YourInfo(); } break; case 53: { // "ExpressScan" ExpressScan(); } break; case 54: { // "WWIVVer" WWIVVersion(); } break; case 55: { // "InstanceEdit" InstanceEdit(); } break; case 56: { // "ConferenceEdit" JumpEdit(); } break; case 57: { // "SubEdit" BoardEdit(); } break; case 58: { // "ChainEdit" ChainEdit(); } break; case 59: { // "ToggleAvailable" ToggleChat(); } break; case 60: { // "ChangeUser" ChangeUser(); } break; case 61: { // "CLOUT" CallOut(); } break; case 62: { // "Debug" Debug(); } break; case 63: { // "DirEdit" DirEdit(); } break; case 65: { // "Edit" EditText(); } break; case 66: { // "BulletinEdit" EditBulletins(); } break; case 67: { // "LoadText" // LoadText and LoadTextFile are the same, so they are now merged. LoadTextFile(); } break; case 68: { // "ReadAllMail" ReadAllMail(); } break; case 69: { // "Reboot" RebootComputer(); } break; case 70: { // "ReloadMenus" ReloadMenus(); } break; case 71: { // "ResetUserIndex" ResetFiles(); } break; case 72: { // "ResetQScan" ResetQscan(); } break; case 73: { // "MemStat" MemoryStatus(); } break; case 74: { // "PackMsgs" PackMessages(); } break; case 75: { // "VoteEdit" InitVotes(); } break; case 76: { // "Log" ReadLog(); } break; case 77: { // "NetLog" ReadNetLog(); } break; case 78: { // "Pending" PrintPending(); } break; case 79: { // "Status" PrintStatus(); } break; case 80: { // "TextEdit" TextEdit(); } break; case 81: { // "UserEdit" UserEdit(); } break; case 82: { // "VotePrint" VotePrint(); } break; case 83: { // "YLog" YesturdaysLog(); } break; case 84: { // "ZLog" ZLog(); } break; case 85: { // "ViewNetDataLog" ViewNetDataLog(); } break; case 86: { // "UploadPost" UploadPost(); } break; case 87: { // "ClearScreen" GetSession()->bout.ClearScreen(); } break; case 88: { // "NetListing" NetListing(); } break; case 89: { // "WHO" WhoIsOnline(); } break; case 90: { // /A "NewMsgsAllConfs" NewMsgsAllConfs(); } break; case 91: { // /E "MultiEMail" MultiEmail(); } break; case 92: { // "NewMsgScanFromHere" NewMsgScanFromHere(); } break; case 93: { // "ValidatePosts" ValidateScan(); } break; case 94: { // "ChatRoom" ChatRoom(); } break; case 95: { // "DownloadPosts" DownloadPosts(); } break; case 96: { // "DownloadFileList" DownloadFileList(); } break; case 97: { // "ClearQScan" ClearQScan(); } break; case 98: { // "FastGoodBye" FastGoodBye(); } break; case 99: { // "NewFilesAllConfs" NewFilesAllConfs(); } break; case 100: { // "ReadIDZ" ReadIDZ(); } break; case 101: { // "UploadAllDirs" UploadAllDirs(); } break; case 102: { // "UploadCurDir" UploadCurDir(); } break; case 103: { // "RenameFiles" RenameFiles(); } break; case 104: { // "MoveFiles" MoveFiles(); } break; case 105: { // "SortDirs" SortDirs(); } break; case 106: { // "ReverseSortDirs" ReverseSort(); } break; case 107: { // "AllowEdit" AllowEdit(); } break; case 109: { // "UploadFilesBBS" UploadFilesBBS(); } break; case 110: { // "DirList" DirList(); } break; case 111: { // "UpDirConf" UpDirConf(); } break; case 112: { // "UpDir" UpDir(); } break; case 113: { // "DownDirConf" DownDirConf(); } break; case 114: { // "DownDir" DownDir(); } break; case 115: { // "ListUsersDL" ListUsersDL(); } break; case 116: { // "PrintDSZLog" PrintDSZLog(); } break; case 117: { // "PrintDevices" PrintDevices(); } break; case 118: { // "ViewArchive" ViewArchive(); } break; case 119: { // "BatchMenu" BatchMenu(); } break; case 120: { // "Download" Download(); } break; case 121: { // "TempExtract" TempExtract(); } break; case 122: { // "FindDescription" FindDescription(); } break; case 123: { // "ArchiveMenu" TemporaryStuff(); } break; case 124: { // "HopDir" HopDir(); } break; case 125: { // "JumpDirConf" JumpDirConf(); } break; case 126: { // "ListFiles" ListFiles(); } break; case 127: { // "NewFileScan" NewFileScan(); } break; case 128: { // "SetNewFileScanDate" SetNewFileScanDate(); } break; case 129: { // "RemoveFiles" RemoveFiles(); } break; case 130: { // "SearchAllFiles" SearchAllFiles(); } break; case 131: { // "XferDefaults" XferDefaults(); } break; case 132: { // "Upload" Upload(); } break; case 133: { // "YourInfoDL" YourInfoDL(); } break; case 134: { // "UploadToSysop" UploadToSysop(); } break; case 135: { // "ReadAutoMessage" ReadAutoMessage(); } break; case 136: { // "SetNewScanMsg" SetNewScanMsg(); } break; case 137: { // "ReadMessages" ReadMessages(); } break; /* case 138: { // "RUN" ExecuteBasic(szParam1); } break; */ case 139: { // "EventEdit" EventEdit(); } break; case 140: { // "LoadTextFile" LoadTextFile(); } break; case 141: { // "GuestApply" GuestApply(); } break; case 142: { // "ConfigFileList" ConfigFileList(); } break; case 143: { // "ListAllColors" ListAllColors(); } break; #ifdef QUESTIONS case 144: { // "EditQuestions" EditQuestions(); } break; case 145: { // "Questions" Questions(); } break; #endif case 146: { // "RemoveNotThere" RemoveNotThere(); } break; case 147: { // "AttachFile" AttachFile(); } break; case 148: { // "InternetEmail" InternetEmail(); } break; case 149: { // "UnQScan" UnQScan(); } break; // ppMenuStringsIndex[150] thru ppMenuStringsIndex[153] not used..... case 154: { // "Packers" Packers(); } break; case 155: { // Color_Config color_config(); } break; //------------------------------------------------------------------ // ppMenuStringsIndex[156] and [157] are reserved for SDS Systems and systems // that distribute modifications. DO NOT reuse these strings for // other menu options. //------------------------------------------------------------------ // case 156: // { // ModAccess // ModsAccess(); // } break; // case 157: // { // SDSAccess // SDSAccess(); // } break; //------------------------------------------------------------------ case 158: { // InitVotes InitVotes(); } break; case 161: { // TurnMCIOn TurnMCIOn(); } break; case 162: { // TurnMCIOff TurnMCIOff(); } break; default: { MenuSysopLog("The following command was not recognized"); MenuSysopLog(szCmd); } break; } } }