home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / sd386v50.zip / sd386src.zip / RX.C < prev    next >
C/C++ Source or Header  |  1996-02-02  |  69KB  |  1,251 lines
  1. /*****************************************************************************/
  2. /* File:                                             IBM INTERNAL USE ONLY   */
  3. /*   rx.c                                                                    */
  4. /*                                                                           */
  5. /* Description:                                                              */
  6. /*                                                                           */
  7. /*  Execute x-server functions.                                              */
  8. /*                                                                           */
  9. /* History:                                                                  */
  10. /*                                                                           */
  11. /*   06/24/93 Created.                                                       */
  12. /*                                                                           */
  13. /*...                                                                        */
  14. /*... 06/24/92  827   Joe   Add support for remote debug.                    */
  15. /*... 05/05/94  919   Joe   Add child process support.                       */
  16. /*...                                                                        */
  17. /*****************************************************************************/
  18. #include "all.h"
  19.  
  20. /*****************************************************************************/
  21. /* RxFindExe()                                                               */
  22. /*                                                                           */
  23. /* Description:                                                              */
  24. /*                                                                           */
  25. /*   This is server find EXE function.                                       */
  26. /*                                                                           */
  27. /* Parameters:                                                               */
  28. /*                                                                           */
  29. /*   cmd        received command structure containing the length of          */
  30. /*              the parameter packet.                                        */
  31. /*                                                                           */
  32. /* Return:                                                                   */
  33. /*                                                                           */
  34. /*   none.                                                                   */
  35. /*                                                                           */
  36. /* Assumptions:                                                              */
  37. /*                                                                           */
  38. /*   none.                                                                   */
  39. /*                                                                           */
  40. /*****************************************************************************/
  41. void RxFindExe(COMMAND cmd)
  42. {
  43.  char         *progname;
  44.  ULONG         base;
  45.  TXRX_FINDEXE  ParmPacket;
  46.  RET_FINDEXE   ReturnPacket;
  47.  
  48.  memset(ReturnPacket.buffer,0,sizeof(ReturnPacket.buffer));
  49.  RmtRecv(DEFAULT_HANDLE,&ParmPacket,cmd.len);
  50.  base = (ULONG)&ParmPacket;
  51.  progname = (char*)(base + (ULONG)ParmPacket.progname);
  52.  
  53.  
  54.  ReturnPacket.rc = XSrvFindExe( progname,ReturnPacket.buffer,
  55.                                 sizeof(ReturnPacket.buffer) );
  56.  
  57.  cmd.api = FINDEXE;
  58.  cmd.len = sizeof(APIRET) + strlen(ReturnPacket.buffer) + 1;
  59.  RmtSend(DEFAULT_HANDLE,&cmd,sizeof(cmd));
  60.  RmtSend(DEFAULT_HANDLE,&ReturnPacket,cmd.len );
  61. }
  62.  
  63. /*****************************************************************************/
  64. /* RxStartUser()                                                             */
  65. /*                                                                           */
  66. /* Description:                                                              */
  67. /*                                                                           */
  68. /*   Start( DosStartSession ) the debuggee.                                  */
  69. /*                                                                           */
  70. /*   The parameter packet for DosStartSession consists of:                   */
  71. /*    - the STARTDATA structure +                                            */
  72. /*    - PgmTitle string +                                                    */
  73. /*    - PgmName  string +                                                    */
  74. /*    - PgmInputs string.                                                    */
  75. /*                                                                           */
  76. /* Parameters:                                                               */
  77. /*                                                                           */
  78. /*   cmd        received command structure containing the length of          */
  79. /*              the parameter packet.                                        */
  80. /*                                                                           */
  81. /* Return:                                                                   */
  82. /*                                                                           */
  83. /*   none.                                                                   */
  84. /*                                                                           */
  85. /* Assumptions:                                                              */
  86. /*                                                                           */
  87. /*   pUserEXE != NULL                                                        */
  88. /*                                                                           */
  89. /*****************************************************************************/
  90. void RxStartUser(COMMAND cmd)
  91. {
  92.  
  93.  TXRX_STARTUSER  ParmPacket;
  94.  RET_STARTUSER   ReturnPacket;
  95.  char           *pParmPacket;
  96.  char           *pUserEXE;
  97.  char           *pUserParms;
  98.  USHORT          SessionType;
  99.  ULONG           ErrorBufLen;
  100.  
  101.  /****************************************************************************/
  102.  /* - receive the parm packet.                                               */
  103.  /* - define the ptr to the exe. The string comes over as a length           */
  104.  /*   prefixed z-string so we have to add a +1 to get past the length        */
  105.  /*   prefix.                                                                */
  106.  /* - define the ptr to the program parameters. This is also a length        */
  107.  /*   prefixed z-string.                                                     */
  108.  /****************************************************************************/
  109.  pParmPacket = (char*)&ParmPacket;
  110.  RmtRecv(DEFAULT_HANDLE,pParmPacket,cmd.len);
  111.  
  112.  pUserEXE    = pParmPacket + ParmPacket.pUserEXE + 1;
  113.  
  114.  pUserParms = NULL;
  115.  if( ParmPacket.pUserParms != 0 )
  116.   pUserParms  = pParmPacket + ParmPacket.pUserParms + 1;
  117.  SessionType = ParmPacket.SessionType;
  118.  
  119.  ErrorBufLen = sizeof(ReturnPacket.ErrorBuf);
  120.  
  121.  memset( ReturnPacket.ErrorBuf, 0, ErrorBufLen );
  122.  
  123.  ReturnPacket.rc = EspStartUser( pUserEXE,
  124.                                  pUserParms,
  125.                                  SessionType,
  126.                                 &ReturnPacket.SessionID,
  127.                                 &ReturnPacket.ProcessID,
  128.                                 &ReturnPacket.ProcessType,
  129.                                  ErrorBufLen,
  130.                                  ReturnPacket.ErrorBuf);
  131.  
  132.  cmd.api = STARTUSER;
  133.  
  134.  cmd.len = sizeof(ReturnPacket) - sizeof(ReturnPacket.ErrorBuf);
  135.  
  136.  if( ReturnPacket.rc != 0 )
  137.   cmd.len += strlen(ReturnPacket.ErrorBuf) + 1;
  138.  
  139.  RmtSend( DEFAULT_HANDLE, &cmd, sizeof(cmd) );
  140.  RmtSend( DEFAULT_HANDLE, &ReturnPacket, cmd.len );
  141. }
  142.  
  143. /*****************************************************************************/
  144. /* RxGoInit()                                                                */
  145. /*                                                                           */
  146. /* Description:                                                              */
  147. /*                                                                           */
  148. /*   Initialize the EXE file for debugging.                                  */
  149. /*                                                                           */
  150. /* Parameters:                                                               */
  151. /*                                                                           */
  152. /*   cmd        received command structure containing the length of          */
  153. /*              the parameter packet.                                        */
  154. /*                                                                           */
  155. /* Return:                                                                   */
  156. /*                                                                           */
  157. /*   none.                                                                   */
  158. /*                                                                           */
  159. /* Assumptions:                                                              */
  160. /*                                                                           */
  161. /*   none.                                                                   */
  162. /*                                                                           */
  163. /*****************************************************************************/
  164. void RxGoInit(COMMAND cmd)
  165. {
  166.  TXRX_GOINIT  ParmPacket;
  167.  RET_GOINIT   ReturnPacket;
  168.  UINT        *pModuleLoadTable = NULL;
  169.  int          ModuleLoadTableLength = 0;
  170.  
  171.  RmtRecv(DEFAULT_HANDLE,&ParmPacket,cmd.len);
  172.  
  173.  memset(&ReturnPacket,0,sizeof(ReturnPacket));
  174.  ReturnPacket.ptb.Pid = ParmPacket.Pid;
  175.  ReturnPacket.ptb.Tid = ParmPacket.Sid;
  176.  
  177.  ReturnPacket.rc = XSrvGoInit(&ReturnPacket.ptb,
  178.                               &ReturnPacket.ExecAddr,
  179.                               &pModuleLoadTable,
  180.                               &ModuleLoadTableLength);
  181.  
  182.  cmd.api = GOINIT;
  183.  cmd.len = sizeof(APIRET) + sizeof(PtraceBuffer);
  184.  
  185.  RmtSend(DEFAULT_HANDLE,&cmd,sizeof(cmd));
  186.  RmtSend(DEFAULT_HANDLE,&ReturnPacket,cmd.len );
  187.  
  188.  cmd.len = ModuleLoadTableLength;
  189.  RmtSend(DEFAULT_HANDLE,&cmd,sizeof(cmd));
  190.  RmtSend(DEFAULT_HANDLE,pModuleLoadTable,cmd.len );
  191.  
  192.  /****************************************************************************/
  193.  /* Free the storage allocated for the module table.                         */
  194.  /****************************************************************************/
  195.  if(pModuleLoadTable)
  196.   Tfree(pModuleLoadTable);
  197. }
  198.  
  199. /*****************************************************************************/
  200. /* RxGoStep()                                                                */
  201. /*                                                                           */
  202. /* Description:                                                              */
  203. /*                                                                           */
  204. /*   Step the deguggee.                                                      */
  205. /*                                                                           */
  206. /* Parameters:                                                               */
  207. /*                                                                           */
  208. /*   cmd        received command structure containing the length of          */
  209. /*              the parameter packet.                                        */
  210. /*                                                                           */
  211. /* Return:                                                                   */
  212. /*                                                                           */
  213. /*   none.                                                                   */
  214. /*                                                                           */
  215. /* Assumptions:                                                              */
  216. /*                                                                           */
  217. /*   none.                                                                   */
  218. /*                                                                           */
  219. /*****************************************************************************/
  220. void RxGoStep(COMMAND cmd)
  221. {
  222.  TXRX_GOSTEP ParmPacket;
  223.  RET_GOSTEP  ReturnPacket;
  224.  UINT       *pModuleLoadTable = NULL;
  225.  int         ModuleLoadTableLength = 0;
  226.  
  227.  RmtRecv(DEFAULT_HANDLE,&ParmPacket,cmd.len);
  228.  ReturnPacket.ptb = ParmPacket.ptb;
  229.  
  230.  if(SerialParallel() == SERIAL)
  231.  {
  232.   SerialConnect( DISCONNECT, GetEspProcessID(), _ESP, SendMsgToEspQue );
  233.  }
  234.  ReturnPacket.rc=XSrvGoStep(&ReturnPacket.ptb,
  235.                             &ReturnPacket.ExecAddr,
  236.                             &pModuleLoadTable,
  237.                             &ModuleLoadTableLength,
  238.                             ParmPacket.ExecAddr,
  239.                             ParmPacket.ExecAddrlo,
  240.                             ParmPacket.ExecAddrhi,
  241.                             ParmPacket.how,
  242.                             ParmPacket.ExecFlags );
  243.  
  244.  if(SerialParallel() == SERIAL)                                         /*919*/
  245.   SerialConnect( CONNECT_WAIT, GetEspProcessID(), _ESP, SendMsgToEspQue );
  246.  cmd.api = GOSTEP;
  247.  cmd.len = sizeof(ReturnPacket);
  248.  
  249.  RmtSend(DEFAULT_HANDLE,&cmd,sizeof(cmd));
  250.  RmtSend(DEFAULT_HANDLE,&ReturnPacket,cmd.len );
  251.  
  252.  cmd.len = ModuleLoadTableLength;
  253.  RmtSend(DEFAULT_HANDLE,&cmd,sizeof(cmd));
  254.  RmtSend(DEFAULT_HANDLE,pModuleLoadTable,cmd.len );
  255.  
  256.  /****************************************************************************/
  257.  /* Free the storage allocated for the module table.                         */
  258.  /****************************************************************************/
  259.  if(pModuleLoadTable)
  260.   Tfree(pModuleLoadTable);
  261. }
  262.  
  263. /*****************************************************************************/
  264. /* RxGoFast()                                                                */
  265. /*                                                                           */
  266. /* Description:                                                              */
  267. /*                                                                           */
  268. /*   Run  the deguggee.                                                      */
  269. /*                                                                           */
  270. /* Parameters:                                                               */
  271. /*                                                                           */
  272. /*   cmd        received command structure containing the length of          */
  273. /*              the parameter packet.                                        */
  274. /*                                                                           */
  275. /* Return:                                                                   */
  276. /*                                                                           */
  277. /*   none.                                                                   */
  278. /*                                                                           */
  279. /* Assumptions:                                                              */
  280. /*                                                                           */
  281. /*   none.                                                                   */
  282. /*                                                                           */
  283. /*****************************************************************************/
  284. void RxGoFast(COMMAND cmd)
  285. {
  286.  TXRX_GOFAST ParmPacket;
  287.  RET_GOFAST  ReturnPacket;
  288.  UINT       *pModuleLoadTable = NULL;
  289.  int         ModuleLoadTableLength = 0;
  290.  
  291.  RmtRecv(DEFAULT_HANDLE,&ParmPacket,cmd.len);
  292.  ReturnPacket.ptb = ParmPacket.ptb;
  293.  
  294.  if(SerialParallel() == SERIAL)                                         /*919*/
  295.  {
  296.   SerialConnect( DISCONNECT, GetEspProcessID(), _ESP, SendMsgToEspQue );
  297.  }
  298.  ReturnPacket.rc=XSrvGoFast(&ReturnPacket.ptb,
  299.                             &ReturnPacket.ExecAddr,
  300.                             &pModuleLoadTable,
  301.                             &ModuleLoadTableLength,
  302.                             ParmPacket.ExecAddr,
  303.                             ParmPacket.ExecFlags);
  304.  if(SerialParallel() == SERIAL)                                         /*919*/
  305.   SerialConnect( CONNECT_WAIT, GetEspProcessID(), _ESP, SendMsgToEspQue );
  306.  cmd.api = GOFAST;
  307.  cmd.len = sizeof(ReturnPacket);
  308.  
  309.  RmtSend(DEFAULT_HANDLE,&cmd,sizeof(cmd));
  310.  RmtSend(DEFAULT_HANDLE,&ReturnPacket,cmd.len );
  311.  
  312.  cmd.len = ModuleLoadTableLength;
  313.  RmtSend(DEFAULT_HANDLE,&cmd,sizeof(cmd));
  314.  RmtSend(DEFAULT_HANDLE,pModuleLoadTable,cmd.len );
  315.  /****************************************************************************/
  316.  /* Free the storage allocated for the module table.                         */
  317.  /****************************************************************************/
  318.  if(pModuleLoadTable)
  319.  {
  320.   Tfree(pModuleLoadTable);
  321.  }
  322. }
  323.  
  324. /*****************************************************************************/
  325. /* RxGoEntry()                                                               */
  326. /*                                                                           */
  327. /* Description:                                                              */
  328. /*                                                                           */
  329. /*   Run to the initial entry point.                                         */
  330. /*                                                                           */
  331. /* Parameters:                                                               */
  332. /*                                                                           */
  333. /*   cmd        received command structure containing the length of          */
  334. /*              the parameter packet.                                        */
  335. /*                                                                           */
  336. /* Return:                                                                   */
  337. /*                                                                           */
  338. /*   none.                                                                   */
  339. /*                                                                           */
  340. /* Assumptions:                                                              */
  341. /*                                                                           */
  342. /*   none.                                                                   */
  343. /*                                                                           */
  344. /*****************************************************************************/
  345. void RxGoEntry(COMMAND cmd)
  346. {
  347.  TXRX_GOFAST ParmPacket;
  348.  RET_GOFAST  ReturnPacket;
  349.  UINT       *pModuleLoadTable = NULL;
  350.  int         ModuleLoadTableLength = 0;
  351.  
  352.  RmtRecv(DEFAULT_HANDLE,&ParmPacket,cmd.len);
  353.  ReturnPacket.ptb = ParmPacket.ptb;
  354.  
  355.  ReturnPacket.rc=XSrvGoFast(&ReturnPacket.ptb,
  356.                             &ReturnPacket.ExecAddr,
  357.                             &pModuleLoadTable,
  358.                             &ModuleLoadTableLength,
  359.                             ParmPacket.ExecAddr,
  360.                             ParmPacket.ExecFlags);
  361.  
  362.  cmd.api = GOENTRY;
  363.  cmd.len = sizeof(ReturnPacket);
  364.  
  365.  RmtSend(DEFAULT_HANDLE,&cmd,sizeof(cmd));
  366.  RmtSend(DEFAULT_HANDLE,&ReturnPacket,cmd.len );
  367.  
  368.  cmd.len = ModuleLoadTableLength;
  369.  RmtSend(DEFAULT_HANDLE,&cmd,sizeof(cmd));
  370.  RmtSend(DEFAULT_HANDLE,pModuleLoadTable,cmd.len );
  371.  /****************************************************************************/
  372.  /* Free the storage allocated for the module table.                         */
  373.  /****************************************************************************/
  374.  if(pModuleLoadTable)
  375.   Tfree(pModuleLoadTable);
  376. }
  377.  
  378. /*****************************************************************************/
  379. /* RxDefBrk()                                                                */
  380. /*                                                                           */
  381. /* Description:                                                              */
  382. /*                                                                           */
  383. /*   Define a breakpoint.                                                    */
  384. /*                                                                           */
  385. /* Parameters:                                                               */
  386. /*                                                                           */
  387. /*   cmd        received command structure containing the length of          */
  388. /*              the parameter packet.                                        */
  389. /*                                                                           */
  390. /* Return:                                                                   */
  391. /*                                                                           */
  392. /*   none.                                                                   */
  393. /*                                                                           */
  394. /* Assumptions:                                                              */
  395. /*                                                                           */
  396. /*   none.                                                                   */
  397. /*                                                                           */
  398. /*****************************************************************************/
  399. void   RxDefBrk(COMMAND cmd)
  400. {
  401.  TXRX_DEFBRK ParmPacket;
  402.  
  403.  RmtRecv(DEFAULT_HANDLE,&ParmPacket,cmd.len);
  404.  XSrvDefBrk( ParmPacket.where );
  405. }
  406. /*****************************************************************************/
  407. /* RxUndBrk()                                                                */
  408. /*                                                                           */
  409. /* Description:                                                              */
  410. /*                                                                           */
  411. /*   Undefine a breakpoint.                                                  */
  412. /*                                                                           */
  413. /* Parameters:                                                               */
  414. /*                                                                           */
  415. /*   cmd        received command structure containing the length of          */
  416. /*              the parameter packet.                                        */
  417. /*                                                                           */
  418. /* Return:                                                                   */
  419. /*                                                                           */
  420. /*   none.                                                                   */
  421. /*                                                                           */
  422. /* Assumptions:                                                              */
  423. /*                                                                           */
  424. /*   none.                                                                   */
  425. /*                                                                           */
  426. /*****************************************************************************/
  427. void   RxUndBrk(COMMAND cmd)
  428. {
  429.  TXRX_UNDBRK ParmPacket;
  430.  
  431.  RmtRecv(DEFAULT_HANDLE,&ParmPacket,cmd.len);
  432.  XSrvUndBrk( ParmPacket.where );
  433. }
  434.  
  435. /*****************************************************************************/
  436. /* RxPutInBrk()                                                              */
  437. /*                                                                           */
  438. /* Description:                                                              */
  439. /*                                                                           */
  440. /*   Put in the CC.                                                          */
  441. /*                                                                           */
  442. /* Parameters:                                                               */
  443. /*                                                                           */
  444. /*   cmd        received command structure containing the length of          */
  445. /*              the parameter packet.                                        */
  446. /*                                                                           */
  447. /* Return:                                                                   */
  448. /*                                                                           */
  449. /*   none.                                                                   */
  450. /*                                                                           */
  451. /* Assumptions:                                                              */
  452. /*                                                                           */
  453. /*   none.                                                                   */
  454. /*                                                                           */
  455. /*****************************************************************************/
  456. void   RxPutInBrk(COMMAND cmd)
  457. {
  458.  TXRX_PUTINBRK ParmPacket;
  459.  
  460.  RmtRecv(DEFAULT_HANDLE,&ParmPacket,cmd.len);
  461.  XSrvPutInBrk( ParmPacket.where );
  462. }
  463.  
  464. /*****************************************************************************/
  465. /* RxPullOutBrk()                                                            */
  466. /*                                                                           */
  467. /* Description:                                                              */
  468. /*                                                                           */
  469. /*   Pull out the CC.                                                        */
  470. /*                                                                           */
  471. /* Parameters:                                                               */
  472. /*                                                                           */
  473. /*   cmd        received command structure containing the length of          */
  474. /*              the parameter packet.                                        */
  475. /*                                                                           */
  476. /* Return:                                                                   */
  477. /*                                                                           */
  478. /*   none.                                                                   */
  479. /*                                                                           */
  480. /* Assumptions:                                                              */
  481. /*                                                                           */
  482. /*   none.                                                                   */
  483. /*                                                                           */
  484. /*****************************************************************************/
  485. void   RxPullOutBrk(COMMAND cmd)
  486. {
  487.  TXRX_PULLOUTBRK ParmPacket;
  488.  
  489.  RmtRecv(DEFAULT_HANDLE,&ParmPacket,cmd.len);
  490.  XSrvPullOutBrk( ParmPacket.where );
  491. }
  492.  
  493. /*****************************************************************************/
  494. /* RxInsertAllBrk()                                                          */
  495. /*                                                                           */
  496. /* Description:                                                              */
  497. /*                                                                           */
  498. /*   Put in CCs for all defined breakpoints.                                 */
  499. /*                                                                           */
  500. /* Parameters:                                                               */
  501. /*                                                                           */
  502. /* Return:                                                                   */
  503. /*                                                                           */
  504. /* Assumptions:                                                              */
  505. /*                                                                           */
  506. /*****************************************************************************/
  507. void   RxInsertAllBrk( void )
  508. {
  509.  XSrvInsertAllBrk( );
  510. }
  511.  
  512. /*****************************************************************************/
  513. /* RxRemoveAllBrk()                                                          */
  514. /*                                                                           */
  515. /* Description:                                                              */
  516. /*                                                                           */
  517. /*   Remove all CCs for all defined breakpoints.                             */
  518. /*                                                                           */
  519. /* Parameters:                                                               */
  520. /*                                                                           */
  521. /* Return:                                                                   */
  522. /*                                                                           */
  523. /* Assumptions:                                                              */
  524. /*                                                                           */
  525. /*****************************************************************************/
  526. void   RxRemoveAllBrk( void )
  527. {
  528.  XSrvRemoveAllBrk( );
  529. }
  530.  
  531. /*****************************************************************************/
  532. /* RxDosDebug()                                                              */
  533. /*                                                                           */
  534. /* Description:                                                              */
  535. /*                                                                           */
  536. /*   X-server DosDebug API handler.                                          */
  537. /*                                                                           */
  538. /* Parameters:                                                               */
  539. /*                                                                           */
  540. /*   cmd        received command structure containing the length of          */
  541. /*              the parameter packet.                                        */
  542. /*                                                                           */
  543. /* Return:                                                                   */
  544. /*                                                                           */
  545. /*   none.                                                                   */
  546. /*                                                                           */
  547. /* Assumptions:                                                              */
  548. /*                                                                           */
  549. /*   none.                                                                   */
  550. /*                                                                           */
  551. /*****************************************************************************/
  552. void RxDosDebug(COMMAND cmd)
  553. {
  554.  TXRX_DOSDEBUG ParmPacket;
  555.  RET_DOSDEBUG  ReturnPacket;
  556.  long          DebugCmd;
  557.  
  558.  RmtRecv(DEFAULT_HANDLE,&ParmPacket,cmd.len);
  559.  
  560.  ReturnPacket.ptb = ParmPacket.ptb;
  561.  
  562.  DebugCmd = cmd.cmd;
  563.  switch( DebugCmd )
  564.  {
  565.   case DBG_C_ReadMemBuf:
  566.   case DBG_C_ThrdStat:
  567.    ReturnPacket.ptb.Buffer = (ULONG)&ReturnPacket.buffer;
  568.    break;
  569.  
  570.  
  571.   case DBG_C_WriteMemBuf:
  572.    ReturnPacket.ptb.Buffer = (ULONG)&ParmPacket.buffer;
  573.    break;
  574.  
  575.  }
  576.  
  577.  ReturnPacket.rc = DosDebug( &ReturnPacket.ptb );
  578.  
  579.  cmd.len = sizeof(ReturnPacket.rc) + sizeof(ReturnPacket.ptb);
  580.  if( (ReturnPacket.rc == 0 ) &&
  581.      ( (DebugCmd == DBG_C_ReadMemBuf) || (DebugCmd == DBG_C_ThrdStat) )
  582.    )
  583.  {
  584.   cmd.len += ParmPacket.ptb.Len;
  585.  }
  586.  
  587.  cmd.api = DOSDEBUG;
  588.  RmtSend(DEFAULT_HANDLE,&cmd,sizeof(cmd));
  589.  RmtSend(DEFAULT_HANDLE,&ReturnPacket,cmd.len);
  590. }
  591.  
  592. /*****************************************************************************/
  593. /* RxGetThreadInfo()                                                         */
  594. /*                                                                           */
  595. /* Description:                                                              */
  596. /*                                                                           */
  597. /*    Get the thread info for the debuggee.                                  */
  598. /*                                                                           */
  599. /* Parameters:                                                               */
  600. /*                                                                           */
  601. /*   cmd        received command structure containing the length of          */
  602. /*              the parameter packet.                                        */
  603. /*                                                                           */
  604. /* Return:                                                                   */
  605. /*                                                                           */
  606. /*   none                                                                    */
  607. /*                                                                           */
  608. /* Assumptions:                                                              */
  609. /*                                                                           */
  610. /*   none.                                                                   */
  611. /*                                                                           */
  612. /*****************************************************************************/
  613. void RxGetThreadInfo(COMMAND cmd)
  614. {
  615.  ULONG   ntids;
  616.  RET_GETTHREADINFO ReturnPacket;
  617.  
  618.  ntids = XSrvGetThreadInfo((THREADINFO *)&ReturnPacket.ti);
  619.  ReturnPacket.ntids = ntids;
  620.  
  621.  cmd.api  = GETTHREADINFO;
  622.  cmd.len  = sizeof(ReturnPacket.ntids) + ntids*sizeof(THREADINFO);
  623.  
  624.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  625.  RmtSend(DEFAULT_HANDLE,&ReturnPacket,cmd.len);
  626. }
  627.  
  628. /*****************************************************************************/
  629. /* RxFreezeThread()                                                          */
  630. /*                                                                           */
  631. /* Description:                                                              */
  632. /*                                                                           */
  633. /*   Freeze a thread.                                                        */
  634. /*                                                                           */
  635. /* Parameters:                                                               */
  636. /*                                                                           */
  637. /*   cmd        received command structure containing the length of          */
  638. /*              the parameter packet.                                        */
  639. /*                                                                           */
  640. /* Return:                                                                   */
  641. /*                                                                           */
  642. /*   void                                                                    */
  643. /*                                                                           */
  644. /* Assumptions:                                                              */
  645. /*                                                                           */
  646. /*   none.                                                                   */
  647. /*                                                                           */
  648. /*****************************************************************************/
  649. void  RxFreezeThread(COMMAND cmd)
  650. {
  651.  ULONG   tid;
  652.  
  653.  RmtRecv(DEFAULT_HANDLE,&tid,cmd.len);
  654.  XSrvFreezeThread(tid);
  655.  cmd.api  = FREEZETHREAD;
  656.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  657. }
  658. /*****************************************************************************/
  659. /* TxThawThread()                                                            */
  660. /*                                                                           */
  661. /* Description:                                                              */
  662. /*                                                                           */
  663. /*   Thaw a thread.                                                          */
  664. /*                                                                           */
  665. /* Parameters:                                                               */
  666. /*                                                                           */
  667. /*   cmd        received command structure containing the length of          */
  668. /*              the parameter packet.                                        */
  669. /*                                                                           */
  670. /* Return:                                                                   */
  671. /*                                                                           */
  672. /*   void                                                                    */
  673. /*                                                                           */
  674. /* Assumptions:                                                              */
  675. /*                                                                           */
  676. /*   none.                                                                   */
  677. /*                                                                           */
  678. /*****************************************************************************/
  679. void  RxThawThread(COMMAND cmd)
  680. {
  681.  ULONG   tid;
  682.  
  683.  RmtRecv(DEFAULT_HANDLE,&tid,cmd.len);
  684.  XSrvThawThread(tid);
  685.  cmd.api  = THAWTHREAD;
  686.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  687. }
  688. /*****************************************************************************/
  689. /* RxGetCallStack()                                                          */
  690. /*                                                                           */
  691. /* Description:                                                              */
  692. /*                                                                           */
  693. /*   Get the call stack tables.                                              */
  694. /*                                                                           */
  695. /* Parameters:                                                               */
  696. /*                                                                           */
  697. /*   cmd        received command structure containing the length of          */
  698. /*              the parameter packet.                                        */
  699. /*                                                                           */
  700. /* Return:                                                                   */
  701. /*                                                                           */
  702. /*   void                                                                    */
  703. /*                                                                           */
  704. /* Assumptions:                                                              */
  705. /*                                                                           */
  706. /*   none.                                                                   */
  707. /*                                                                           */
  708. /*****************************************************************************/
  709. void RxGetCallStack(COMMAND cmd )
  710. {
  711.  ULONG    NActFrames = 0;
  712.  UCHAR   *pActCSAtrs = NULL;
  713.  UINT    *pActFrames = NULL;
  714.  UINT    *pActFaddrs = NULL;
  715.  int      size;
  716.  int      nbytes;
  717.  char    *ptable;
  718.  TXRX_GETCALLSTACK ParmPacket;
  719.  RET_GETCALLSTACK  *pReturnPacket;
  720.  
  721.  RmtRecv(DEFAULT_HANDLE, &ParmPacket, cmd.len );
  722.  
  723.  NActFrames = XSrvGetCallStack( &ParmPacket.parms,
  724.                                 &pActCSAtrs,
  725.                                 &pActFrames,
  726.                                 &pActFaddrs );
  727.  
  728.  
  729.  size = sizeof(RET_GETCALLSTACK) - 1 +
  730.         NActFrames*(sizeof(UCHAR) + sizeof(UINT) + sizeof(UINT) );
  731.  
  732.  pReturnPacket = Talloc(size);
  733.  
  734.  pReturnPacket->NActFrames = NActFrames;
  735.  
  736.  ptable = pReturnPacket->buffer;
  737.  nbytes = NActFrames*sizeof(UCHAR);
  738.  memcpy(ptable,pActCSAtrs,nbytes);
  739.  pReturnPacket->pActCSAtrs = (ULONG)(ptable - (char*)pReturnPacket);
  740.  
  741.  ptable = ptable + nbytes;
  742.  nbytes = NActFrames*sizeof(UINT);
  743.  memcpy(ptable,pActFrames,nbytes);
  744.  pReturnPacket->pActFrames = (ULONG)(ptable - (char*)pReturnPacket);
  745.  
  746.  ptable = ptable + nbytes;
  747.  nbytes = NActFrames*sizeof(UINT);
  748.  memcpy(ptable,pActFaddrs,nbytes);
  749.  pReturnPacket->pActFaddrs = (ULONG)(ptable - (char*)pReturnPacket);
  750.  
  751.  if(pActCSAtrs) Tfree(pActCSAtrs);
  752.  if(pActFrames) Tfree(pActFrames);
  753.  if(pActFaddrs) Tfree(pActFaddrs);
  754.  
  755.  cmd.len = size;
  756.  RmtSend(DEFAULT_HANDLE, &cmd  , sizeof(cmd) );
  757.  RmtSend(DEFAULT_HANDLE, pReturnPacket, cmd.len );
  758.  
  759.  Tfree(pReturnPacket);
  760. }
  761.  
  762. /*****************************************************************************/
  763. /* RxGetExeOrDllEntryOrExitPt()                                              */
  764. /*                                                                           */
  765. /* Description:                                                              */
  766. /*                                                                           */
  767. /*   Get the entry point for a dll or exe.                                   */
  768. /*                                                                           */
  769. /* Parameters:                                                               */
  770. /*                                                                           */
  771. /*   cmd        received command structure containing the length of          */
  772. /*              the parameter packet.                                        */
  773. /*                                                                           */
  774. /* Return:                                                                   */
  775. /*                                                                           */
  776. /*   void                                                                    */
  777. /*                                                                           */
  778. /* Assumptions:                                                              */
  779. /*                                                                           */
  780. /*   none.                                                                   */
  781. /*                                                                           */
  782. /*****************************************************************************/
  783. void RxGetExeOrDllEntryOrExitPt( COMMAND cmd )
  784. {
  785.  UINT  mte;
  786.  ULONG EntryPtAddr = 0;
  787.  
  788.  RmtRecv(DEFAULT_HANDLE, &mte, cmd.len );
  789.  
  790.  EntryPtAddr = XSrvGetExeOrDllEntryOrExitPt( mte );
  791.  
  792.  cmd.api  = GETEXEORDLLENTRY;
  793.  cmd.len  = sizeof(EntryPtAddr);
  794.  
  795.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  796.  RmtSend(DEFAULT_HANDLE, &EntryPtAddr, cmd.len );
  797. }
  798.  
  799. /*****************************************************************************/
  800. /* RxNormalQuit()                                                            */
  801. /*                                                                           */
  802. /* Description:                                                              */
  803. /*                                                                           */
  804. /*   Terminate the debuggee process.                                         */
  805. /*                                                                           */
  806. /* Parameters:                                                               */
  807. /*                                                                           */
  808. /*   cmd        received command structure containing the length of          */
  809. /*              the parameter packet.                                        */
  810. /*                                                                           */
  811. /* Return:                                                                   */
  812. /*                                                                           */
  813. /*   void                                                                    */
  814. /*                                                                           */
  815. /* Assumptions:                                                              */
  816. /*                                                                           */
  817. /*   none.                                                                   */
  818. /*                                                                           */
  819. /*****************************************************************************/
  820. void RxNormalQuit( COMMAND cmd )
  821. {
  822.  TXRX_GETEXEORDLLENTRY ParmPacket;
  823.  
  824.  RmtRecv(DEFAULT_HANDLE, &ParmPacket, cmd.len );
  825.  
  826.  XSrvNormalQuit( ParmPacket.AppTerminated,
  827.                  ParmPacket.mte,
  828.                  ParmPacket.EntryPt );
  829. }
  830.  
  831. /*****************************************************************************/
  832. /* RxSetExecAddr()                                                           */
  833. /*                                                                           */
  834. /* Description:                                                              */
  835. /*                                                                           */
  836. /*   Set the exec address for the current thread.                            */
  837. /*                                                                           */
  838. /* Parameters:                                                               */
  839. /*                                                                           */
  840. /*   cmd        received command structure containing the length of          */
  841. /*              the parameter packet.                                        */
  842. /*                                                                           */
  843. /* Return:                                                                   */
  844. /*                                                                           */
  845. /*   rc                                                                      */
  846. /*                                                                           */
  847. /* Assumptions:                                                              */
  848. /*                                                                           */
  849. /*   none.                                                                   */
  850. /*                                                                           */
  851. /*****************************************************************************/
  852. void RxSetExecAddr( COMMAND cmd )
  853. {
  854.  ULONG ExecAddr;
  855.  APIRET  rc;
  856.  
  857.  RmtRecv(DEFAULT_HANDLE, &ExecAddr, cmd.len );
  858.  rc = XSrvSetExecAddr( ExecAddr );
  859.  
  860.  cmd.api  = SETEXECADDR;
  861.  cmd.len  = sizeof(rc);
  862.  
  863.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  864.  RmtSend(DEFAULT_HANDLE, &rc , cmd.len );
  865. }
  866.  
  867. /*****************************************************************************/
  868. /* RxDefWps()                                                                */
  869. /*                                                                           */
  870. /* Description:                                                              */
  871. /*                                                                           */
  872. /*   Define the watch points in the x-server.                                */
  873. /*                                                                           */
  874. /* Parameters:                                                               */
  875. /*                                                                           */
  876. /*   cmd        received command structure containing the length of          */
  877. /*              the parameter packet.                                        */
  878. /*                                                                           */
  879. /* Return:                                                                   */
  880. /*                                                                           */
  881. /*   rc                                                                      */
  882. /*                                                                           */
  883. /* Assumptions:                                                              */
  884. /*                                                                           */
  885. /*   none.                                                                   */
  886. /*                                                                           */
  887. /*****************************************************************************/
  888. void RxDefWps( COMMAND cmd )
  889. {
  890.  TXRX_DEFWPS ParmPacket;
  891.  
  892.  RmtRecv(DEFAULT_HANDLE, &ParmPacket, cmd.len );
  893.  XSrvDefWps( &ParmPacket.regs, ParmPacket.size);
  894.  
  895.  cmd.api  = DEFWPS;
  896.  cmd.len  = 0;
  897.  
  898.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  899. }
  900.  
  901. /*****************************************************************************/
  902. /* RxPutInWps()                                                              */
  903. /*                                                                           */
  904. /* Description:                                                              */
  905. /*                                                                           */
  906. /*   Put in the watch points.                                                */
  907. /*                                                                           */
  908. /* Parameters:                                                               */
  909. /*                                                                           */
  910. /*   cmd        received command structure containing the length of          */
  911. /*              the parameter packet.                                        */
  912. /*                                                                           */
  913. /* Return:                                                                   */
  914. /*                                                                           */
  915. /* Assumptions:                                                              */
  916. /*                                                                           */
  917. /*   none.                                                                   */
  918. /*                                                                           */
  919. /*****************************************************************************/
  920. void RxPutInWps( COMMAND cmd )
  921. {
  922.  RET_PUTINWPS ReturnPacket;
  923.  
  924.  
  925.  XSrvPutInWps( ReturnPacket.indexes );
  926.  
  927.  cmd.api  = PUTINWPS;
  928.  cmd.len  = sizeof(ReturnPacket);
  929.  
  930.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  931.  RmtSend(DEFAULT_HANDLE, &ReturnPacket, cmd.len );
  932. }
  933.  
  934. /*****************************************************************************/
  935. /* RxPullOutWps()                                                            */
  936. /*                                                                           */
  937. /* Description:                                                              */
  938. /*                                                                           */
  939. /*   Pull out the watch points.                                              */
  940. /*                                                                           */
  941. /* Parameters:                                                               */
  942. /*                                                                           */
  943. /*   cmd        received command structure containing the length of          */
  944. /*              the parameter packet.                                        */
  945. /*                                                                           */
  946. /* Return:                                                                   */
  947. /*                                                                           */
  948. /*   rc                                                                      */
  949. /*                                                                           */
  950. /* Assumptions:                                                              */
  951. /*                                                                           */
  952. /*   none.                                                                   */
  953. /*                                                                           */
  954. /*****************************************************************************/
  955. void RxPullOutWps( COMMAND cmd )
  956. {
  957.  XSrvPullOutWps( );
  958.  
  959.  cmd.api  = PUTINWPS;
  960.  cmd.len  = 0;
  961.  
  962.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  963. }
  964.  
  965. /*****************************************************************************/
  966. /* RxGetDataBytes()                                                          */
  967. /*                                                                           */
  968. /* Description:                                                              */
  969. /*                                                                           */
  970. /*   Get a block of data.                                                    */
  971. /*                                                                           */
  972. /* Parameters:                                                               */
  973. /*                                                                           */
  974. /*   cmd        received command structure containing the length of          */
  975. /*              the parameter packet.                                        */
  976. /*                                                                           */
  977. /* Return:                                                                   */
  978. /*                                                                           */
  979. /* Assumptions:                                                              */
  980. /*                                                                           */
  981. /*   BytesWanted <= 16.                                                      */
  982. /*                                                                           */
  983. /*****************************************************************************/
  984. void RxGetDataBytes( COMMAND cmd )
  985. {
  986.  TXRX_GETDATABYTES ParmPacket;
  987.  RET_GETDATABYTES  ReturnPacket;
  988.  int               BytesWanted;
  989.  int               BytesObtained;
  990.  UCHAR            *pbytes;
  991.  ULONG             addr;
  992.  
  993.  RmtRecv(DEFAULT_HANDLE, &ParmPacket, cmd.len );
  994.  
  995.  addr        = ParmPacket.addr;
  996.  BytesWanted = ParmPacket.BytesWanted;
  997.  
  998.  pbytes = XSrvGetMemoryBlock( addr,BytesWanted, &BytesObtained );
  999.  
  1000.  cmd.api  = GETDATABYTES;
  1001.  cmd.len = sizeof(ReturnPacket.BytesObtained) + BytesObtained;
  1002.  
  1003.  ReturnPacket.BytesObtained = BytesObtained;
  1004.  if(pbytes && ( BytesObtained != 0 ) )
  1005.   memcpy(ReturnPacket.bytes,pbytes,BytesObtained);
  1006.  
  1007.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  1008.  RmtSend(DEFAULT_HANDLE, &ReturnPacket, cmd.len );
  1009. }
  1010.  
  1011. /*****************************************************************************/
  1012. /* RxGetMemBlocks()                                                          */
  1013. /*                                                                           */
  1014. /* Description:                                                              */
  1015. /*                                                                           */
  1016. /*   Get some memory blocks.                                                 */
  1017. /*                                                                           */
  1018. /* Parameters:                                                               */
  1019. /*                                                                           */
  1020. /*   cmd        received command structure containing the length of          */
  1021. /*              the parameter packet.                                        */
  1022. /*                                                                           */
  1023. /* Return:                                                                   */
  1024. /*                                                                           */
  1025. /* Assumptions:                                                              */
  1026. /*                                                                           */
  1027. /*****************************************************************************/
  1028. void RxGetMemBlocks( COMMAND cmd )
  1029. {
  1030.  void  *pDefBlks = NULL;
  1031.  void  *pMemBlks = NULL;
  1032.  int    MemBlkSize;
  1033.  
  1034.  pDefBlks = Talloc( cmd.len );
  1035.  
  1036.  RmtRecv(DEFAULT_HANDLE, pDefBlks, cmd.len );
  1037.  pMemBlks = XSrvGetMemoryBlocks( pDefBlks, &MemBlkSize );
  1038.  
  1039.  cmd.api = GETMEMBLKS;
  1040.  cmd.len = MemBlkSize;
  1041.  
  1042.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  1043.  RmtSend(DEFAULT_HANDLE, pMemBlks, cmd.len );
  1044.  Tfree( pMemBlks );
  1045. }
  1046.  
  1047. /*****************************************************************************/
  1048. /* RxSetExceptions()                                                         */
  1049. /*                                                                           */
  1050. /* Description:                                                              */
  1051. /*                                                                           */
  1052. /*   Set the exception notify/nonotify map.                                  */
  1053. /*                                                                           */
  1054. /* Parameters:                                                               */
  1055. /*                                                                           */
  1056. /*   cmd        received command structure containing the length of          */
  1057. /*              the parameter packet.                                        */
  1058. /*                                                                           */
  1059. /* Return:                                                                   */
  1060. /*                                                                           */
  1061. /* Assumptions:                                                              */
  1062. /*                                                                           */
  1063. /*****************************************************************************/
  1064. void RxSetExceptions( COMMAND cmd )
  1065. {
  1066.  UCHAR XcptMap[MAXEXCEPTIONS+1];
  1067.  int   length;
  1068.  
  1069.  length = cmd.len;
  1070.  
  1071.  RmtRecv(DEFAULT_HANDLE, XcptMap, length );
  1072.  XSrvSetExceptions( XcptMap, length );
  1073.  
  1074.  cmd.api = SETXCPTNOTIFY;
  1075.  cmd.len = 0;
  1076.  
  1077.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  1078. }
  1079. /*****************************************************************************/
  1080. /* RxSetExecThread()                                                         */
  1081. /*                                                                           */
  1082. /* Description:                                                              */
  1083. /*                                                                           */
  1084. /*   Set execution context to a specified thread.                            */
  1085. /*                                                                           */
  1086. /* Parameters:                                                               */
  1087. /*                                                                           */
  1088. /*   cmd        received command structure containing the length of          */
  1089. /*              the parameter packet.                                        */
  1090. /*                                                                           */
  1091. /* Return:                                                                   */
  1092. /*                                                                           */
  1093. /*   none.                                                                   */
  1094. /*                                                                           */
  1095. /* Assumptions:                                                              */
  1096. /*                                                                           */
  1097. /*   none.                                                                   */
  1098. /*                                                                           */
  1099. /*****************************************************************************/
  1100. void RxSetExecThread(COMMAND cmd)
  1101. {
  1102.  UINT tid;
  1103.  RET_SETEXECTHREAD ReturnPacket;
  1104.  
  1105.  RmtRecv(DEFAULT_HANDLE,&tid,cmd.len);
  1106.  
  1107.  memset(&ReturnPacket,0,sizeof(ReturnPacket));
  1108.  
  1109.  ReturnPacket.rc = XSrvSetExecThread(&ReturnPacket.ExecAddr,
  1110.                                      &ReturnPacket.ptb,
  1111.                                      tid);
  1112.  
  1113.  cmd.api = SETEXECTHREAD;
  1114.  cmd.len = sizeof(ReturnPacket);
  1115.  
  1116.  RmtSend(DEFAULT_HANDLE,&cmd,sizeof(cmd));
  1117.  RmtSend(DEFAULT_HANDLE,&ReturnPacket,cmd.len );
  1118.  
  1119. }
  1120.  
  1121. /*****************************************************************************/
  1122. /* RxWriteRegs()                                                             */
  1123. /*                                                                           */
  1124. /* Description:                                                              */
  1125. /*                                                                           */
  1126. /*   Write the registers to the app.                                         */
  1127. /*                                                                           */
  1128. /* Parameters:                                                               */
  1129. /*                                                                           */
  1130. /*   cmd        received command structure containing the length of          */
  1131. /*              the parameter packet.                                        */
  1132. /*                                                                           */
  1133. /* Return:                                                                   */
  1134. /*                                                                           */
  1135. /*   none.                                                                   */
  1136. /*                                                                           */
  1137. /* Assumptions:                                                              */
  1138. /*                                                                           */
  1139. /*   none.                                                                   */
  1140. /*                                                                           */
  1141. /*****************************************************************************/
  1142. void RxWriteRegs(COMMAND cmd)
  1143. {
  1144.  PtraceBuffer ptb;
  1145.  RET_WRITEREGS ReturnPacket;
  1146.  
  1147.  RmtRecv(DEFAULT_HANDLE, &ptb,cmd.len);
  1148.  
  1149.  ReturnPacket.rc = XSrvWriteRegs(&ReturnPacket.ExecAddr,&ptb);
  1150.  
  1151.  cmd.api = WRITEREGS;
  1152.  cmd.len = sizeof(ReturnPacket);
  1153.  
  1154.  RmtSend(DEFAULT_HANDLE,&cmd,sizeof(cmd));
  1155.  RmtSend(DEFAULT_HANDLE,&ReturnPacket,cmd.len );
  1156.  
  1157. }
  1158.  
  1159. /*****************************************************************************/
  1160. /* RxGetCoRegs()                                                             */
  1161. /*                                                                           */
  1162. /* Description:                                                              */
  1163. /*                                                                           */
  1164. /*   Get the co-processor registers.                                         */
  1165. /*                                                                           */
  1166. /* Parameters:                                                               */
  1167. /*                                                                           */
  1168. /*   cmd        received command structure containing the length of          */
  1169. /*              the parameter packet.                                        */
  1170. /*                                                                           */
  1171. /* Return:                                                                   */
  1172. /*                                                                           */
  1173. /*   none.                                                                   */
  1174. /*                                                                           */
  1175. /* Assumptions:                                                              */
  1176. /*                                                                           */
  1177. /*   none.                                                                   */
  1178. /*                                                                           */
  1179. /*****************************************************************************/
  1180. void RxGetCoRegs(COMMAND cmd)
  1181. {
  1182.  RET_GETCOREGS ReturnPacket;
  1183.  
  1184.  ReturnPacket.rc = XSrvGetCoRegs(&ReturnPacket.coproc_regs);
  1185.  
  1186.  cmd.api = GETCOREGS;
  1187.  cmd.len = sizeof(ReturnPacket);
  1188.  
  1189.  RmtSend(DEFAULT_HANDLE,&cmd,sizeof(cmd));
  1190.  RmtSend(DEFAULT_HANDLE,&ReturnPacket,cmd.len );
  1191. }
  1192.  
  1193. /*****************************************************************************/
  1194. /* RxSetEspRunOpts()                                                      919*/
  1195. /*                                                                           */
  1196. /* Description:                                                              */
  1197. /*                                                                           */
  1198. /*   Receive the esp run options.                                            */
  1199. /*                                                                           */
  1200. /* Parameters:                                                               */
  1201. /*                                                                           */
  1202. /*   cmd        received command structure containing the length of          */
  1203. /*              the parameter packet.                                        */
  1204. /*                                                                           */
  1205. /* Return:                                                                   */
  1206. /*                                                                           */
  1207. /* Assumptions:                                                              */
  1208. /*                                                                           */
  1209. /*****************************************************************************/
  1210. void RxSetEspRunOpts( COMMAND cmd )
  1211. {
  1212.  ESP_RUN_OPTS *pOpts = NULL;
  1213.  
  1214.  pOpts = (ESP_RUN_OPTS*)Talloc(cmd.len);
  1215.  RmtRecv(DEFAULT_HANDLE, pOpts, cmd.len );
  1216.  EspSetEspRunOpts( pOpts);
  1217.  if(pOpts) Tfree(pOpts);
  1218. }
  1219.  
  1220. /*****************************************************************************/
  1221. /* RxStartEspQue()                                                        919*/
  1222. /*                                                                           */
  1223. /* Description:                                                              */
  1224. /*                                                                           */
  1225. /*   Start up a que to manage esp messages.                                  */
  1226. /*                                                                           */
  1227. /* Parameters:                                                               */
  1228. /*                                                                           */
  1229. /*   cmd        received command structure containing the length of          */
  1230. /*              the parameter packet.                                        */
  1231. /*                                                                           */
  1232. /* Return:                                                                   */
  1233. /*                                                                           */
  1234. /*   rc                                                                      */
  1235. /*                                                                           */
  1236. /* Assumptions:                                                              */
  1237. /*                                                                           */
  1238. /*****************************************************************************/
  1239. void RxStartEspQue( COMMAND cmd )
  1240. {
  1241.  APIRET rc;
  1242.  
  1243.  rc = StartEspQue( );
  1244.  
  1245.  cmd.api  = START_ESP_QUE;
  1246.  cmd.len  = sizeof(rc);
  1247.  
  1248.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  1249.  RmtSend(DEFAULT_HANDLE, &rc  , cmd.len );
  1250. }
  1251.