home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / ibmtool.zip / intrface.c < prev    next >
Text File  |  1997-11-07  |  19KB  |  556 lines
  1. /******************************************************************************/
  2. /*                                                                            */
  3. /*      FILE: INTRFACE.C                                                      */
  4. /*                                                                            */
  5. /*   PURPOSE: This file contains the internal command line and script file    */
  6. /*            processing.                                                     */
  7. /*                                                                            */
  8. /* FUNCTIONS: InitInterface                                                   */
  9. /*            ParseCommand                                                    */
  10. /*            InsertCharStr                                                   */
  11. /*            GetCommand                                                      */
  12. /*            DoScript                                                        */
  13. /*                                                                            */
  14. /* GLOBAL DATA ACCESSED                                                       */
  15. /*      char    HelpCmd[15]                                                   */
  16. /*      int     CmdFromHelp                                                   */
  17. /*      int     LastMenuOpt                                                   */
  18. /*      int     PrevMenuOpt                                                   */
  19. /*      int     CurrMenuOpt                                                   */
  20. /*      BOOLEAN ScriptMode                                                    */
  21. /*      BOOLEAN SLog                                                          */
  22. /*      USHORT  LastStatus                                                    */
  23. /*      FILE   *ScriptFile,                                                   */
  24. /*             *LogFile                                                       */
  25. /*      MENU    MenuBar[]                                                     */
  26. /*      WINDOW  CmdLine                                                       */
  27. /*                                                                            */
  28. /******************************************************************************/
  29.  
  30. #define INCL_SUB
  31. #define INCL_BASE
  32. #define INCL_DOS
  33. #include <os2.h>
  34. #include <stdio.h>
  35. #include <stdarg.h>
  36. #include <malloc.h>
  37. #include <stdlib.h>
  38. #include <string.h>
  39. #include <ctype.h>
  40. #include "ndis.h"
  41. #include "ibmtool.h"
  42. #include "ioctl.h"
  43. #include "intrface.h"
  44.  
  45. struct CMDQUEUE {
  46.   char   Cmd[MAXSTRING];
  47.   struct CMDQUEUE *next;
  48.   struct CMDQUEUE *prev;
  49. } CmdQ[MAXCMDS];
  50. struct CMDQUEUE *CQTop, *CQBot, *CurCmd;
  51.  
  52. BOOLEAN  MenuMode = FALSE;
  53.  
  54. COMMAND Cmds[] = {
  55.     { "ADDMC"     ,      TTAddMulticastAddr    },
  56.     { "CHKDATA"   ,      TTCheckData           },
  57.     { "CHKIND"    ,      TTCheckIndications    },
  58.     { "CHKLK"     ,      TTCheckLookahead      },
  59.     { "CHKSTAT"   ,      TTCheckStatus         },
  60.     { "CHKTOKEN"   ,     TTCheckTokenRing      },
  61.     { "CLOSE"     ,      TTClose               },
  62.     { "CLRIND"    ,      TTClearIndications    },
  63.     { "CLRMAC"    ,      TTClearMAC            },
  64.     { "CSTAT"     ,      TTClearStat           },
  65.     { "DEBUG"     ,      TTDebug               },
  66.     { "DELMC"     ,      TTDeleteMulticastAddr },
  67.     { "ECHO"      ,      TTEcho                },
  68.     { "EDITBUF"   ,      TTEditBuffer          },
  69.     { "EXIT"      ,      TTExit                },
  70.     { "FILTER"    ,      TTSetPacketFilter     },
  71.     { "FUNADR"    ,      TTSetFunctionalAddr   },
  72.     { "HELP"      ,      Help                  },
  73.     { "INDCOMP"   ,      TTIndComp             },
  74.     { "INDICON"   ,      TTIndicationsOn       },
  75.     { "INDICOFF"  ,      TTIndicationsOff      },
  76.     { "INITDIAG"  ,      TTInitiateDiagnostics },
  77.     { "INTREQ"    ,      TTInterruptRequest    },
  78.     { "INT3"      ,      TTInt3                },
  79.     { "JUMP"      ,      TTJump                },
  80.     { "LOG"       ,      TTLog                 },
  81.     { "MODOPEN"   ,      TTModifyOpenParms     },
  82.     { "MONITOR"   ,      TTMonitor             },
  83.     { "MULTRAN"   ,      TTMultipleXmit        },
  84.     { "OPEN"      ,      TTOpen                },
  85.     { "QUIT"      ,      TTExit                },
  86.     { "READMAC"   ,      TTReadMAC             },
  87.     { "READLOG"   ,      TTReadErrorLog        },
  88.     { "REQCONF"   ,      TTReqConf             },
  89.     { "RESET"     ,      TTResetMAC            },
  90.     { "RUN"       ,      TTRun                 },
  91.     { "RXBUF"     ,      TTDispRcvBufs         },
  92.     { "RXCHAIN"   ,      TTRxChain             },
  93.     { "RXLOOK"    ,      TTRxLook              },
  94.     { "RXRLS"     ,      TTReceiveRelease      },
  95.     { "RXSIZE"    ,      TTSetRxBuffSize       },
  96.     { "RXWAIT"    ,      TTRxWait              },
  97.     { "SERVER"    ,      TTServer              },
  98.     { "SETLOOK"   ,      TTSetLookAhead        },
  99.     { "SETSTAT"   ,      TTSetStatus           },
  100.     { "SETSTN"    ,      TTSetStationAddr      },
  101.     { "SRVTX"     ,      TTServerXmit          },
  102.     { "STATIND"   ,      TTStatInd             },
  103.     { "STRESS"    ,      TTStress              },
  104.     { "TRAN"      ,      TTXmit                },
  105.     { "TXBUF"     ,      TTDispXmitBuf         },
  106.     { "TXCONF"    ,      TTTxConf              },
  107.     { "TXSIZE"    ,      TTSetTxBuffSize       },
  108.     { "USEGDT"    ,      TTUseGDT              },
  109.     { "USTAT"     ,      TTUpdateStatistics    },
  110.     { "SLEEP"     ,      TTSleep               },
  111.     { "VER"       ,      TTVersion             },
  112.     { "WKSTA"     ,      TTWorkstation         },
  113.     { "?"         ,      DoIHelp               },
  114.     { ""          ,      NULL                  }  };
  115.  
  116. char *RcString[] = { "OK",                               // 0
  117.                      "Invalid Parameter",                // 1
  118.                      "DEBUG NOT ON",                     // 2
  119.                      "General Request did not complete", // 3
  120.                      "NO SERVER FOUND"                   // 4
  121.                    };
  122.  
  123. void InitInterface ()
  124. {
  125.   int         i, j;
  126.   VIOMODEINFO ModeInfo;
  127.  
  128.   // initialize some global variables
  129.   CmdFromHelp = FALSE;
  130.   HelpMode    = FALSE;
  131.  
  132.   // initialize the command queue
  133.   for (i=0; i<MAXCMDS; ++i)
  134.      for (j=0; j<MAXSTRING; ++j)
  135.         CmdQ[i].Cmd[j] = '\0';
  136.  
  137.   CQBot = CQTop = CurCmd = &CmdQ[0];
  138.   for (i=0; i<MAXCMDS - 1; ++i)
  139.      CmdQ[i].next = &CmdQ[i+1];
  140.   CmdQ[i].next = &CmdQ[0];
  141.   for (i=MAXCMDS - 1; i>0; --i)
  142.      CmdQ[i].prev = &CmdQ[i-1];
  143.   CmdQ[i].prev = &CmdQ[MAXCMDS - 1];
  144.  
  145.   // set video mode
  146.   ModeInfo.cb = sizeof (VIOMODEINFO);
  147.   VioGetMode (&ModeInfo, 0);
  148.   ModeInfo.col = MAXCOL + 1;
  149.   ModeInfo.row = MAXROW + 1;
  150.   VioSetMode (&ModeInfo, 0);
  151.  
  152.   InitMsg ();
  153.   InitMenu ();
  154.   InitHelp ();
  155.   InitScreen ();
  156. }
  157.  
  158. void ParseCommand (char *cmd)
  159. {
  160.   char    newcmd[MAXSTRING];
  161.   char    temp[15];
  162.   char   *CmdTok;
  163.   int     i, rc;
  164.   BOOLEAN found = FALSE;
  165.  
  166.   if (!*cmd) return;
  167.   strcpy (newcmd, cmd);
  168.  
  169.   strupr (cmd);
  170.   if (!ScriptMode && SLog)
  171.     {
  172.      if (strstr (cmd, "\n"))
  173.         fprintf (LogFile, "%s", cmd);
  174.      else
  175.         fprintf (LogFile, "%s\n", cmd);
  176.     }
  177.  
  178.   CmdTok = strtok (cmd, "\n\t ");
  179.   if (!CmdTok) return;
  180.  
  181.   // search the regular command list
  182.   for (i=0; Cmds[i].CmdFunc != NULL; ++i)
  183.     {
  184.      if (!stricmp (CmdTok, Cmds[i].Command))
  185.        {
  186.         found = TRUE;
  187.         rc = Cmds[i].CmdFunc ();
  188.         if (rc)
  189.            PrintMsg (RED, RcString[rc]);
  190.         break;
  191.        }
  192.     } /* endfor */
  193.  
  194.   if (!found)
  195.      PrintMsg (YELLOW, "Command not recognized");
  196.   else if (!ScriptMode)
  197.     {
  198.      strcpy (CQBot->Cmd, newcmd);
  199.      CQBot = CQBot->next;
  200.      CurCmd = CQBot;
  201.      if (CQBot == CQTop) CQTop = CQTop->next;
  202.      UpdateInfo ();
  203.     }
  204. }
  205.  
  206. void InsertCharStr (char *strpos, char ch)
  207. {
  208.   char tstr[MAXSTRING];
  209.   char *q = strpos;
  210.  
  211.   strcpy (tstr, strpos);
  212.   *q++ = ch;
  213.   strcpy (q, tstr);
  214. }
  215.  
  216. void GetCommand ()
  217. {
  218.   BYTE           bAttr[2] = " ";
  219.   char          *p, *s, *token;
  220.   char           cmd[MAXSTRING];
  221.   char           temp[15];
  222.   int            done = 0, i, len = 0, InsertMode = 0;
  223.   USHORT         col, curcol = CmdLine.Left + 1, ySave;
  224.   KBDKEYINFO     KbdInfo, NoKbdInfo = { 0, 0, 0, 0, 0, 0L };
  225.   VIOCURSORINFO  CursorInfo;
  226.  
  227.   VioGetCurType (&CursorInfo, 0);
  228.   ySave = CursorInfo.yStart;
  229.  
  230.   bAttr[1] = CmdLine.Attr;
  231.   s = p = cmd;
  232.   VioSetCurPos (CmdLine.Top, CmdLine.Left + 1, 0);
  233.  
  234.   memset (cmd, '\0', MAXSTRING);
  235.   if (CmdFromHelp)
  236.     {
  237.      strcpy (cmd, HelpCmd);
  238.      curcol += len = strlen (cmd);
  239.      p += len;
  240.      VioWrtCharStrAtt (s, (len < MAXCOL) ? len : MAXCOL,
  241.                        CmdLine.Top, 1, &CmdLine.Attr, 0);
  242.      VioSetCurPos (CmdLine.Top, curcol, 0);
  243.     }
  244.  
  245.   while (!done)
  246.     {
  247.      CheckIndications ();
  248.  
  249.      KbdInfo = NoKbdInfo;
  250.      KbdCharIn (&KbdInfo, IO_NOWAIT, 0);
  251.      if (KbdInfo.fsState & ALT_KEY)
  252.        {
  253.         for (i=0; *MenuBar[i].Option; ++i)
  254.           {
  255.            if (MenuBar[i].SelKey == KbdInfo.chScan)
  256.              {
  257.               SelectMenuOpt (i);
  258.               break;
  259.              }
  260.           } /* endfor */
  261.        }
  262.      else if (isprint (KbdInfo.chChar))
  263.        {
  264.         if (KbdInfo.fsState & INSERT_STATE)
  265.           {
  266.            InsertCharStr (p, KbdInfo.chChar);
  267.            ++p;
  268.           }
  269.         else
  270.            *p++ = KbdInfo.chChar;
  271.         if (curcol != MAXCOL)
  272.            ++curcol;
  273.         else
  274.            ++s;
  275.         ++len;
  276.         VioWrtCharStrAtt (s, (len < MAXCOL) ? len : MAXCOL,
  277.                           CmdLine.Top, 1, &CmdLine.Attr, 0);
  278.         VioSetCurPos (CmdLine.Top, curcol, 0);
  279.        }
  280.      else
  281.        {
  282.         switch (KbdInfo.chScan)
  283.           {
  284.            case ENTER:
  285.              done = 1;
  286.              len = 0;
  287.              if (CmdFromHelp)
  288.                {
  289.                 CmdFromHelp = FALSE;
  290.                 SelectMenuOpt (PrevMenuOpt);
  291.                }
  292.              break;
  293.            case RIGHT:
  294.              if (MenuMode)
  295.                {
  296.                 if (CurrMenuOpt == LastMenuOpt)
  297.                    SelectMenuOpt (0);
  298.                 else
  299.                    SelectMenuOpt (CurrMenuOpt + 1);
  300.                 break;
  301.                }
  302.              if (len && curcol <= len)
  303.                {
  304.                 ++p;
  305.                 if (++curcol > MAXCOL)
  306.                   {
  307.                    curcol = MAXCOL;
  308.                    ++s;
  309.                    VioWrtCharStrAtt (s, (len < MAXCOL) ? len : MAXCOL,
  310.                                      CmdLine.Top, 1, &CmdLine.Attr, 0);
  311.                   }
  312.                 VioSetCurPos (CmdLine.Top, curcol, 0);
  313.                }
  314.              break;
  315.            case LEFT:
  316.              if (MenuMode)
  317.                {
  318.                 if (CurrMenuOpt == 0)
  319.                    SelectMenuOpt (LastMenuOpt);
  320.                 else
  321.                    SelectMenuOpt (CurrMenuOpt - 1);
  322.                 break;
  323.                }
  324.              if (curcol > 1)
  325.                {
  326.                 VioSetCurPos (CmdLine.Top, --curcol, 0);
  327.                 --p;
  328.                }
  329.              if (s != cmd)
  330.                {
  331.                 --s;
  332.                 VioWrtCharStrAtt (s, (len < MAXCOL) ? len : MAXCOL,
  333.                                   CmdLine.Top, 1, &CmdLine.Attr, 0);
  334.                }
  335.              break;
  336.            case UP:
  337.              if (CmdFromHelp)
  338.                {
  339.                 CmdFromHelp = FALSE;
  340.                 SelectMenuOpt (PrevMenuOpt);
  341.                }
  342.              if (CurCmd == CQTop) break;
  343.              CurCmd = CurCmd->prev;
  344.              strcpy (cmd, CurCmd->Cmd);
  345.              len = strlen (cmd);
  346.              p = cmd + len;
  347.              if (len > MAXCOL)
  348.                {
  349.                 s = cmd + len - 78;
  350.                 curcol = MAXCOL;
  351.                }
  352.              else
  353.                {
  354.                 s = cmd;
  355.                 curcol = len + 1;
  356.                }
  357.              VioWrtCharStrAtt (s, len, CmdLine.Top, 1, &CmdLine.Attr, 0);
  358.              VioScrollUp (CmdLine.Top, CmdLine.Left + len + 1,
  359.                           CmdLine.Bottom, -1, -1, bAttr, 0);
  360.              VioSetCurPos (CmdLine.Top, curcol, 0);
  361.              break;
  362.            case DOWN:
  363.              if (CmdFromHelp)
  364.                {
  365.                 CmdFromHelp = FALSE;
  366.                 SelectMenuOpt (PrevMenuOpt);
  367.                }
  368.              CurCmd = CurCmd->next;
  369.              if (CurCmd == CQBot->next) CurCmd = CQBot;
  370.              if (CurCmd == CQBot)
  371.                 memset (cmd, 0, MAXSTRING);
  372.              else
  373.                 strcpy (cmd, CurCmd->Cmd);
  374.              len = strlen (cmd);
  375.              p = cmd + len;
  376.              if (len > MAXCOL)
  377.                {
  378.                 s = cmd + len - 78;
  379.                 curcol = MAXCOL;
  380.                }
  381.              else
  382.                {
  383.                 s = cmd;
  384.                 curcol = len + 1;
  385.                }
  386.              VioWrtCharStrAtt (s, len, CmdLine.Top, 1, &CmdLine.Attr, 0);
  387.              VioScrollUp (CmdLine.Top, CmdLine.Left + len + 1,
  388.                           CmdLine.Bottom, -1, -1, bAttr, 0);
  389.              VioSetCurPos (CmdLine.Top, curcol, 0);
  390.              break;
  391.            case HOME:
  392.              curcol = 1;
  393.              VioWrtCharStrAtt (cmd, (len < MAXCOL) ? len : MAXCOL,
  394.                                CmdLine.Top, 1, &CmdLine.Attr, 0);
  395.              VioSetCurPos (CmdLine.Top, curcol, 0);
  396.              s = p = cmd;
  397.              break;
  398.            case BACKSPACE:
  399.              if (p != cmd)
  400.                {
  401.                 strcpy (p-1, p);
  402.                 *(cmd + strlen (cmd) + 1) = '\0';
  403.                 --curcol;
  404.                 --p;
  405.                 --len;
  406.                }
  407.              VioWrtCharStrAtt (s, (len < MAXCOL) ? len : MAXCOL,
  408.                                CmdLine.Top, 1, &CmdLine.Attr, 0);
  409.              VioScrollUp (CmdLine.Top, CmdLine.Left + len + 1,
  410.                           CmdLine.Bottom, -1, -1, bAttr, 0);
  411.              VioSetCurPos (CmdLine.Top, curcol, 0);
  412.              break;
  413.            case END:
  414.              p = cmd + len;
  415.              if (len > MAXCOL)
  416.                {
  417.                 s = cmd + len - 78;
  418.                 curcol = MAXCOL;
  419.                 VioWrtCharStrAtt (s, (len < MAXCOL) ? len : MAXCOL,
  420.                                   CmdLine.Top, 1, &CmdLine.Attr, 0);
  421.                }
  422.              else
  423.                 curcol = len + 1;
  424.              VioSetCurPos (CmdLine.Top, curcol, 0);
  425.              break;
  426.            case INSERT:
  427.              InsertMode = ~InsertMode;
  428.              if (InsertMode)
  429.                 CursorInfo.yStart = 4;
  430.              else
  431.                 CursorInfo.yStart = ySave;
  432.              VioSetCurType (&CursorInfo, 0);
  433.              if (CmdFromHelp)
  434.                {
  435.                 if ((token == strtok (cmd, "\n\t ")))
  436.                   {
  437.                    strcpy (temp, token);
  438.                    strcat (temp, " ");
  439.                    if (strcmp (temp, HelpCmd))
  440.                      {
  441.                       CmdFromHelp = FALSE;
  442.                       SelectMenuOpt (PrevMenuOpt);
  443.                       memset (cmd, '\0', MAXSTRING);
  444.                       p = s = cmd;
  445.                       len = 0;
  446.                       curcol = 1;
  447.                       ClearWindow (CmdLine);
  448.                       aprintf (CmdLine.Top, CmdLine.Left, CmdLine.Attr, ">");
  449.                       VioSetCurType (&CursorInfo, 0);
  450.                       VioSetCurPos (CmdLine.Top, curcol, 0);
  451.                      }
  452.                   }
  453.                }
  454.              break;
  455.            case DELETE:
  456.              if (*p)
  457.                {
  458.                 strcpy (p, p+1);
  459.                 *(cmd + len + 1) = '\0';
  460.                 --len;
  461.                 VioWrtCharStrAtt (s, (len < MAXCOL) ? len : MAXCOL,
  462.                                   CmdLine.Top, 1, &CmdLine.Attr, 0);
  463.                 VioScrollUp (CmdLine.Top, CmdLine.Left + len + 1,
  464.                              CmdLine.Bottom, -1, -1, bAttr, 0);
  465.                }
  466.              if (CmdFromHelp && len < strlen (HelpCmd))
  467.                {
  468.                 CmdFromHelp = FALSE;
  469.                 SelectMenuOpt (PrevMenuOpt);
  470.                 memset (cmd, '\0', MAXSTRING);
  471.                 p = s = cmd;
  472.                 len = 0;
  473.                 curcol = 1;
  474.                 ClearWindow (CmdLine);
  475.                 aprintf (CmdLine.Top, CmdLine.Left, CmdLine.Attr, ">");
  476.                 VioSetCurType (&CursorInfo, 0);
  477.                 VioSetCurPos (CmdLine.Top, curcol, 0);
  478.                }
  479.              break;
  480.            case TAB:
  481.              DoMessageWindow ();
  482.              VioSetCurPos (CmdLine.Top, curcol, 0);
  483.              break;
  484.            case ESC:
  485.              if (CmdFromHelp)
  486.                {
  487.                 CmdFromHelp = FALSE;
  488.                 SelectMenuOpt (PrevMenuOpt);
  489.                }
  490.              memset (cmd, '\0', MAXSTRING);
  491.              p = s = cmd;
  492.              len = 0;
  493.              curcol = 1;
  494.              ClearWindow (CmdLine);
  495.              aprintf (CmdLine.Top, CmdLine.Left, CmdLine.Attr, ">");
  496.              VioSetCurType (&CursorInfo, 0);
  497.              VioSetCurPos (CmdLine.Top, curcol, 0);
  498.              break;
  499.            case F10:
  500.              if (MenuMode) MenuMode = FALSE;
  501.              else MenuMode = TRUE;
  502.              if (CmdFromHelp)
  503.                {
  504.                 CmdFromHelp = FALSE;
  505.                 SelectMenuOpt (PrevMenuOpt);
  506.                }
  507.              break;
  508.           } /* endswitch */
  509.        } /* endif */
  510.     } /* endwhile */
  511.  
  512.   if (*cmd && !strnicmp (cmd, "RUN ", 4))
  513.     {
  514.      token = strtok (cmd, "\n\t ");
  515.      TTRun ();
  516.     }
  517.   else if (*cmd)
  518.      ParseCommand (cmd);
  519.  
  520.   ClearWindow (CmdLine);
  521.   aprintf (CmdLine.Top, CmdLine.Left, CmdLine.Attr, ">");
  522.   VioSetCurPos (CmdLine.Top, CmdLine.Left + 1, 0);
  523. }
  524.  
  525. void DoScript ()
  526. {
  527.   char  cmd[MAXSTRING];
  528.  
  529.   memset (cmd, '\0', MAXSTRING);
  530.   SLog = TRUE;
  531.  
  532.   while (fgets (cmd, MAXSTRING, ScriptFile))
  533.     {
  534.      CheckIndications ();
  535.  
  536.      if (*cmd != ':')
  537.        {
  538.         if (strstr (cmd, "\n"))
  539.           {
  540.            printf ("%s", cmd);
  541.            fprintf (LogFile, "%s", cmd);
  542.           }
  543.         else
  544.           {
  545.            printf ("%s\n", cmd);
  546.            fprintf (LogFile, "%s\n", cmd);
  547.           }
  548.        }
  549.  
  550.      if (*cmd != '#' && *cmd != ':')
  551.         ParseCommand (cmd);
  552.  
  553.     } /* endwhile */
  554. }
  555.  
  556.