home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / ibmtool.zip / tmac.c < prev    next >
Text File  |  1997-11-07  |  11KB  |  429 lines
  1. /******************************************************************************/
  2. /*                                                                            */
  3. /*      FILE: TMAC.C                                                          */
  4. /*                                                                            */
  5. /*   PURPOSE: This file contains the TestMAC driver specific functions.       */
  6. /*                                                                            */
  7. /* FUNCTIONS: OpenTestMAC                                                     */
  8. /*            TTEditTMBuffer                                                  */
  9. /*            TTIndComp                                                       */
  10. /*            TTRxLook                                                        */
  11. /*            TTRxChain                                                       */
  12. /*            TTTxConf                                                        */
  13. /*            TTReqConf                                                       */
  14. /*            TTStatInd                                                       */
  15. /*            TTReceiveRelease                                                */
  16. /*            TTRxWait                                                        */
  17. /*            TMIndComp                                                       */
  18. /*            TMRxLook                                                        */
  19. /*            TMRxChain                                                       */
  20. /*            TMTxConf                                                        */
  21. /*            TMReqConf                                                       */
  22. /*            TMStatInd                                                       */
  23. /*            TMSetResult                                                     */
  24. /*            TTSetRxBuffSize                                                 */
  25. /*                                                                            */
  26. /******************************************************************************/
  27.  
  28. #define INCL_SUB
  29. #define INCL_BASE
  30. #define INCL_DOS
  31. #include <os2.h>
  32. #include <stdio.h>
  33. #include <stdarg.h>
  34. #include <malloc.h>
  35. #include <stdlib.h>
  36. #include <string.h>
  37. #include <ctype.h>
  38. #include "ndis.h"
  39. #include "ibmtool.h"
  40. #include "ioctl.h"
  41.  
  42. BYTE far *TMRcvBuff;
  43. RXBUFDESC RxBuffDesc;
  44.  
  45. int OpenTestMAC ()
  46. {
  47.   char  *DriverName = "TESTMAC$";
  48.   int    rc;
  49.   USHORT DHandle = (USHORT) hTestMAC, apiAction;
  50.  
  51.   // Open TESTMAC
  52.   if (rc = DosOpen (DriverName,   // char * to device driver to open=TESTMAC$
  53.                     &DHandle,     // address of file handle
  54.                     &apiAction,   // action taken by the DosOpen API function
  55.                     0L,           // file size
  56.                     FILE_NORMAL,  // file attribute
  57.                     FILE_OPEN,    // open flag - file must exist already
  58.                     OPEN_ACCESS_READWRITE | OPEN_SHARE_DENYNONE,  //open mode
  59.                     0L)           //reserved
  60.       )
  61.     {
  62.      PrintMsg (RED, "Failure opening TESTMAC");
  63.     }
  64.  
  65.   hTestMAC = (USHORT) DHandle;
  66.  
  67.   // Allocate the ReceiveLookahead buffer for TestMAC
  68.   TMRcvBuff = (BYTE far *) calloc (MACMSC.MscMaxFrame, sizeof (BYTE));
  69.  
  70.   return rc;
  71. }
  72.  
  73. int TTEditTMBuffer ()
  74. {
  75.   char   *token, *s;
  76.   USHORT  i, j, cnt, data, max;
  77.  
  78.   if (!Debug) return TT_NO_DEBUG;
  79.  
  80.   while ((token = strtok (NULL, "\n\t ")) != NULL)
  81.     {
  82.      if ((s = strstr (token, "*")))
  83.        {
  84.         *s++ = '\0';
  85.         if (sscanf (token, "%d", &cnt) != 1)
  86.            return TT_INVALID_PARAMETER;
  87.         if (sscanf (s, "%02X", &data) != 1)
  88.            return TT_INVALID_PARAMETER;
  89.         max = (cnt > MACMSC.MscMaxFrame) ? MACMSC.MscMaxFrame : cnt;
  90.         for (j=0; j<max; ++j)
  91.            TMRcvBuff[i++] = data;
  92.        }
  93.      else
  94.        {
  95.         if (sscanf (token, "%02X", &data) != 1)
  96.            return TT_INVALID_PARAMETER;
  97.         TMRcvBuff[i++] = data;
  98.        }
  99.     }
  100.  
  101.   return SUCCESS;
  102. }
  103.  
  104. int TTIndComp ()
  105. {
  106.   // INDCOMP
  107.  
  108.   TMAC TMac;
  109.  
  110.   if (!Debug) return TT_NO_DEBUG;
  111.  
  112.   TMac.EventCmd = INDCOMP;
  113.  
  114.   GenIoctl ((void far *) &TMac, hTestMAC);
  115.  
  116.   return SUCCESS;
  117. }
  118.  
  119. int TTRxLook ()
  120. {
  121.   // RXLOOK [Type] [FrameLength] [PassFrameLength] [LookaheadLength]
  122.  
  123.   char *token;
  124.   int   i = 0, RxType = 0;
  125.   TMAC  TMac;
  126.  
  127.   if (!Debug) return TT_NO_DEBUG;
  128.  
  129.   TMac.EventCmd = RXLOOK;
  130.   TMac.Parm[0] = 64;
  131.   TMac.Parm[1] = 64;
  132.   TMac.Parm[2] = 0;
  133.  
  134.   while ((token = strtok (NULL, "\n\t ")))
  135.      sscanf (token, "%d", &TMac.Parm[i++]);
  136.   TMac.DataPtr = (void far *) TMRcvBuff;
  137.  
  138.   GenIoctl ((void far *) &TMac, hTestMAC);
  139.  
  140.   return SUCCESS;
  141. }
  142.  
  143. int TTRxChain ()
  144. {
  145.   // RXCHAIN [Type [NetAddr]] [FrameLength] [PassFrameLength] [Handle]
  146.  
  147.   char *token;
  148.   int   i = 0, RxType = 0;
  149.   TMAC  TMac;
  150.  
  151.   if (!Debug) return TT_NO_DEBUG;
  152.  
  153.   TMac.EventCmd = RXCHAIN;
  154.   TMac.Parm[0] = 64;
  155.   TMac.Parm[1] = 64;
  156.   TMac.Parm[2] = 0;
  157.  
  158.   if ((token = strtok (NULL, "\n\t ")))
  159.      if ((RxType = (int) GetNumericParm (token)) < 0)
  160.         return TT_INVALID_PARAMETER;
  161.  
  162.   while ((token = strtok (NULL, "\n\t ")))
  163.      if ((TMac.Parm[i++] = (int) GetNumericParm (token)) < 0)
  164.         return TT_INVALID_PARAMETER;
  165.  
  166.   TMac.DataPtr = (void far *) &RxBuffDesc;
  167.  
  168.   GenIoctl ((void far *) &TMac, hTestMAC);
  169.  
  170.   return SUCCESS;
  171. }
  172.  
  173. int TTTxConf ()
  174. {
  175.   // TXCONF <Handle> <Status>
  176.  
  177.   char *token;
  178.   int   status;
  179.   TMAC  TMac;
  180.  
  181.   if (!Debug) return TT_NO_DEBUG;
  182.  
  183.   TMac.EventCmd = TXCONF;
  184.  
  185.   // get the handle
  186.   if (!(token = strtok (NULL, "\n\t ")))
  187.      return TT_INVALID_PARAMETER;
  188.   if ((TMac.Parm[0] = (WORD) GetNumericParm (token)) < 0)
  189.      return TT_INVALID_PARAMETER;
  190.  
  191.   // get the status
  192.   if (!(token = strtok (NULL, "\n\t ")))
  193.      return TT_INVALID_PARAMETER;
  194.   if ((status = GetRCInt (token)) < 0)
  195.      return TT_INVALID_PARAMETER;
  196.   TMac.Parm[1] = (WORD) status;
  197.  
  198.   GenIoctl ((void far *) &TMac, hTestMAC);
  199.  
  200.   return SUCCESS;
  201. }
  202.  
  203. int TTReqConf ()
  204. {
  205.   // REQCONF <Handle> <OriginalCommand> <Status>
  206.  
  207.   char *token;
  208.   int   status;
  209.   WORD  orgcmd;
  210.   TMAC  TMac;
  211.  
  212.   if (!Debug) return TT_NO_DEBUG;
  213.  
  214.   TMac.EventCmd = REQCONF;
  215.  
  216.   // get the handle
  217.   if (!(token = strtok (NULL, "\n\t ")))
  218.      return TT_INVALID_PARAMETER;
  219.   if ((TMac.Parm[0] = (WORD) GetNumericParm (token)) < 0)
  220.      return TT_INVALID_PARAMETER;
  221.  
  222.   // get the original_command
  223.   if (!(token = strtok (NULL, "\n\t ")))
  224.      return TT_INVALID_PARAMETER;
  225.   for (orgcmd=0; *GenReqStr[orgcmd]; ++orgcmd)
  226.      if (!stricmp (token, GenReqStr[orgcmd])) break;
  227.   if (!*GenReqStr[orgcmd]) return TT_INVALID_PARAMETER;
  228.   TMac.Parm[1]  = orgcmd + 1;
  229.  
  230.   // get the status
  231.   if (!(token = strtok (NULL, "\n\t ")))
  232.      return TT_INVALID_PARAMETER;
  233.   if ((status = GetRCInt (token)) < 0)
  234.      return TT_INVALID_PARAMETER;
  235.   TMac.Parm[2] = (WORD) status;
  236.  
  237.   GenIoctl ((void far *) &TMac, hTestMAC);
  238.  
  239.   return SUCCESS;
  240. }
  241.  
  242. int TTStatInd ()
  243. {
  244.   // STATIND <Opcode> <Param>
  245.  
  246.   char *token;
  247.   int   i;
  248.   TMAC  TMac;
  249.  
  250.   if (!Debug) return TT_NO_DEBUG;
  251.  
  252.   TMac.EventCmd = STATIND;
  253.  
  254.   for (i=0; i<2; ++i)
  255.     {
  256.      if (!(token = strtok (NULL, "\n\t ")))
  257.         return TT_INVALID_PARAMETER;
  258.      if ((TMac.Parm[i] = (WORD) GetNumericParm (token)) < 0)
  259.         return TT_INVALID_PARAMETER;
  260.     }
  261.  
  262.   GenIoctl ((void far *) &TMac, hTestMAC);
  263.  
  264.   return SUCCESS;
  265. }
  266.  
  267. int TTReceiveRelease ()
  268. {
  269.   // RXRLS <Handle>
  270.  
  271.   char          *token;
  272.   WORD           Handle;
  273.   IOCTLDATA      IOData;
  274.   IOCTLDATA far *IODataPtr = &IOData;
  275.  
  276.   if (!(token = strtok (NULL, "\n\t ")))
  277.      return TT_INVALID_PARAMETER;
  278.   if ((Handle = (WORD) GetNumericParm (token)) < 0)
  279.      return TT_INVALID_PARAMETER;
  280.  
  281.   IOData.ReqCode = MACCMD;
  282.   IOData.Length  = RECEIVERELEASE;
  283.   IOData.SrcDataPtr = (void far *) &Handle;
  284.   IOData.DestDataPtr = NULL;
  285.   GenIoctl ((void far *) IODataPtr, hWedge);
  286.   LastStatus = IOData.ReqCode;
  287.  
  288.   return SUCCESS;
  289. }
  290.  
  291. int TTRxWait ()
  292. {
  293.   // RXWAIT
  294.  
  295.   WedgeCommon->RxWait = ~WedgeCommon->RxWait;
  296.  
  297.   if (WedgeCommon->RxWait)
  298.      aprintf (0, 73, 0x74, "R");
  299.   else
  300.      aprintf (0, 73, 0x70, " ");
  301.  
  302.   return SUCCESS;
  303. }
  304.  
  305. int TMIndComp ()
  306. {
  307.   TMAC  TMac;
  308.  
  309.   TMac.EventCmd = INDCOMP;
  310.   GenIoctl ((void far *) &TMac, hTestMAC);
  311. }
  312.  
  313. int TMRxLook (int Type, WORD FrameLen, WORD PassLen, WORD Lookahead)
  314. {
  315.   int  RxType = Type;
  316.   TMAC TMac;
  317.  
  318.   TMac.EventCmd = RXLOOK;
  319.   TMac.Parm[0]  = FrameLen;
  320.   TMac.Parm[1]  = PassLen;
  321.   TMac.Parm[2]  = Lookahead;
  322.   TMac.DataPtr  = TMRcvBuff;
  323.  
  324.   GenIoctl ((void far *) &TMac, hTestMAC);
  325.  
  326.   return SUCCESS;
  327. }
  328.  
  329. int TMRxChain (int Type, WORD FrameLen, WORD PassLen, WORD Handle)
  330. {
  331.   int  RxType = Type;
  332.   TMAC TMac;
  333.  
  334.   TMac.EventCmd = RXCHAIN;
  335.   TMac.Parm[0]  = FrameLen;
  336.   TMac.Parm[1]  = PassLen;
  337.   TMac.Parm[2]  = Handle;
  338.   TMac.DataPtr  = TMRcvBuff;
  339.  
  340.   GenIoctl ((void far *) &TMac, hTestMAC);
  341.  
  342.   return SUCCESS;
  343. }
  344.  
  345. int TMTxConf (WORD Handle, WORD Status)
  346. {
  347.   TMAC TMac;
  348.  
  349.   TMac.EventCmd = TXCONF;
  350.   TMac.Parm[0]  = Handle;
  351.   TMac.Parm[1]  = Status;
  352.  
  353.   GenIoctl ((void far *) &TMac, hTestMAC);
  354.  
  355.   return SUCCESS;
  356. }
  357.  
  358. int TMReqConf (WORD Handle, WORD Command, WORD Status)
  359. {
  360.   TMAC TMac;
  361.  
  362.   TMac.EventCmd = REQCONF;
  363.   TMac.Parm[0]  = Handle;
  364.   TMac.Parm[1]  = Command;
  365.   TMac.Parm[2]  = Status;
  366.  
  367.   GenIoctl ((void far *) &TMac, hTestMAC);
  368.  
  369.   return TMac.Parm[2];
  370.  
  371.   return SUCCESS;
  372. }
  373.  
  374. int TMStatInd (WORD OpCode, WORD Param)
  375. {
  376.   TMAC TMac;
  377.  
  378.   TMac.EventCmd = STATIND;
  379.   TMac.Parm[0]  = OpCode;
  380.   TMac.Parm[1]  = Param;
  381.  
  382.   GenIoctl ((void far *) &TMac, hTestMAC);
  383.  
  384.   return SUCCESS;
  385. }
  386.  
  387. int TMSetResult (WORD Result)
  388. {
  389.   TMAC TMac;
  390.  
  391.   TMac.EventCmd = SETRESULT;
  392.   TMac.Parm[0] = Result;
  393.  
  394.   GenIoctl ((void far *) &TMac, hTestMAC);
  395.  
  396.   return SUCCESS;
  397. }
  398.  
  399. int TTSetRxBuffSize ()
  400. {
  401.   // RXSIZE [BufferSize(s)]
  402.   //        if no parameters given, then display buffer sizes
  403.  
  404.   char *token;
  405.   int   i, offset = 0;
  406.   WORD  BlkCnt = 0, BlkSize;
  407.  
  408.   while (((token = strtok (NULL, "\n\t ")) != NULL) &&
  409.          (BlkCnt < MACMSC.MscMaxDataBlocks))
  410.     {
  411.      RxBuffDesc.RxDataBlk[BlkCnt].RxDataPtr = TMRcvBuff + offset;
  412.      if ((BlkSize = (WORD) GetNumericParm (token)) < 0)
  413.         return TT_INVALID_PARAMETER;
  414.      RxBuffDesc.RxDataBlk[BlkCnt].RxDataLen = BlkSize;
  415.      offset += BlkSize;
  416.      BlkCnt = ++RxBuffDesc.RxDataCnt;
  417.     }
  418.  
  419.   if (!offset)
  420.     {
  421.      for (i=0; i<RxBuffDesc.RxDataCnt; ++i)
  422.         PrintMsg (0, "Rx Data Block %d Length: %d",
  423.                   i, RxBuffDesc.RxDataBlk[i].RxDataLen);
  424.     }
  425.  
  426.   return SUCCESS;
  427. }
  428.  
  429.