home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / sd386v50.zip / sd386src.zip / TX.C < prev    next >
C/C++ Source or Header  |  1996-05-13  |  81KB  |  1,537 lines
  1. /*****************************************************************************/
  2. /* File:                                             IBM INTERNAL USE ONLY   */
  3. /*   tx.c                                                                 827*/
  4. /*                                                                           */
  5. /* Description:                                                              */
  6. /*                                                                           */
  7. /*   x-server remote functions calls.                                        */
  8. /*                                                                           */
  9. /* History:                                                                  */
  10. /*                                                                           */
  11. /*   06/24/93 Created.                                                       */
  12. /*                                                                           */
  13. /*... 06/24/93  827   Joe       Add remote debug support.                    */
  14. /*... 03/29/94  917   Joe       Ctrl-Break handling for single process.      */
  15. /*...                                                                        */
  16. /*****************************************************************************/
  17. #include "all.h"
  18.  
  19. /*****************************************************************************/
  20. /* TxFindExe()                                                               */
  21. /*                                                                           */
  22. /* Description:                                                              */
  23. /*                                                                           */
  24. /*   Find the EXE file from the server. Search in the following order:       */
  25. /*                                                                           */
  26. /*     1. Explicit program name including path reference.                    */
  27. /*     2. Current directory.                                                 */
  28. /*     3. SD386SRC environment variable.                                     */
  29. /*     4. PATH environment variable.                                         */
  30. /*                                                                           */
  31. /* Parameters:                                                               */
  32. /*                                                                           */
  33. /*   progname The filespec of the EXE we're looking for.                     */
  34. /*   pn       Pointer to the caller's buffer to receive filespec.            */
  35. /*   pnlen    Length of the caller's buffer.                                 */
  36. /*                                                                           */
  37. /* Return:                                                                   */
  38. /*                                                                           */
  39. /*   rc       The return code from DosSearchPath().                          */
  40. /*                                                                           */
  41. /* Assumptions:                                                              */
  42. /*                                                                           */
  43. /*  The EXE extension has been added to the filespec.                        */
  44. /*                                                                           */
  45. /*****************************************************************************/
  46. APIRET TxFindExe(char *progname,char *pn,UINT pnlen)
  47. {
  48.  COMMAND      cmd;
  49.  ULONG        LengthofProgName;
  50.  TXRX_FINDEXE ParmPacket;
  51.  RET_FINDEXE  ReturnPacket;
  52.  
  53.  memset(&ParmPacket,0,sizeof(ParmPacket) );
  54.  LengthofProgName = strlen(progname) + 1;
  55.  memcpy(ParmPacket.buffer,progname,LengthofProgName);
  56.  ParmPacket.progname = (ULONG)((ULONG)ParmPacket.buffer-(ULONG)&ParmPacket);
  57.  ParmPacket.pnlen = pnlen;
  58.  ParmPacket.pn    = NULL;
  59.  
  60.  cmd.api = FINDEXE;
  61.  cmd.cmd = 0;
  62.  cmd.len = sizeof(ULONG)+sizeof(char*)+sizeof(UINT)+LengthofProgName;
  63.  
  64.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  65.  RmtSend(DEFAULT_HANDLE, &ParmPacket, cmd.len );
  66.  
  67.  memset(&ReturnPacket,0,sizeof(ReturnPacket) );
  68.  RmtRecv(DEFAULT_HANDLE, &cmd, sizeof(cmd) );
  69.  RmtRecv(DEFAULT_HANDLE, &ReturnPacket, cmd.len );
  70.  memcpy(pn,ReturnPacket.buffer,cmd.len);
  71.  return( ReturnPacket.rc );
  72. }
  73.  
  74. /*****************************************************************************/
  75. /* TxStartUser()                                                             */
  76. /*                                                                           */
  77. /* Description:                                                              */
  78. /*                                                                           */
  79. /*   Start the debuggee in the xserver.                                      */
  80. /*                                                                           */
  81. /* Parameters:                                                               */
  82. /*                                                                           */
  83. /*   pUserEXE       -> fully qualified debuggee specification.               */
  84. /*   pUserParms     -> debuggee parms.                                       */
  85. /*   SessionType       user specified session type.                          */
  86. /*   pSessionID        where to put the SessionID.                           */
  87. /*   pProcessID        where to put the ProcessID.                           */
  88. /*   pProcessType      receiver of the Process Type.                         */
  89. /*   pMsgBuf        -> buffer to receive offending module name.              */
  90. /*                                                                           */
  91. /* Return:                                                                   */
  92. /*                                                                           */
  93. /*   rc            rc from DosStartSession on the remote debuggee.           */
  94. /*                                                                           */
  95. /* Assumptions:                                                              */
  96. /*                                                                           */
  97. /*   pUserExe   != NULL                                                      */
  98. /*   pUserParms may be = NULL                                                */
  99. /*                                                                           */
  100. /*****************************************************************************/
  101. APIRET TxStartUser(char   *pUserEXE,
  102.                    char   *pUserParms,
  103.                    USHORT  SessionType,
  104.                    ULONG  *pSessionID,
  105.                    ULONG  *pProcessID,
  106.                    ULONG  *pProcessType,
  107.                    char   *pMsgBuf )
  108. {
  109.  TXRX_STARTUSER  ParmPacket;
  110.  RET_STARTUSER   ReturnPacket;
  111.  COMMAND cmd;
  112.  UCHAR  *p;
  113.  UCHAR  *dcp;
  114.  UCHAR  *scp;
  115.  ULONG   ParmPacketLen;
  116.  UCHAR  *pParmPacket;
  117.  ULONG   ReturnPacketLen;
  118.  
  119.  /****************************************************************************/
  120.  /* - Compute the length of the parm packet.                                 */
  121.  /* - Copy the exe name to the parm packet.                                  */
  122.  /* - Copy the session type to the parm packet.                              */
  123.  /* - If parms, then copy those to the parm packet.                          */
  124.  /****************************************************************************/
  125.  ParmPacketLen = sizeof(pUserEXE) + sizeof(pUserParms) + sizeof(SessionType);
  126.  ParmPacketLen += 1 + strlen(pUserEXE) + 1;
  127.  if(pUserParms)
  128.   ParmPacketLen += 1 + strlen(pUserParms) + 1;
  129.  
  130.  p   = pParmPacket = (UCHAR*)&ParmPacket;
  131.  dcp = ParmPacket.buffer;
  132.  scp = pUserEXE;
  133.  
  134.  memset(&ParmPacket,0,sizeof(ParmPacket));
  135.  
  136.  ParmPacket.SessionType = SessionType;
  137.  ParmPacket.pUserEXE = (ULONG)(dcp - p);
  138.  
  139.  *dcp++ = strlen(pUserEXE);
  140.  strcpy(dcp,scp);
  141.  
  142.  if(pUserParms)
  143.  {
  144.   dcp += strlen(dcp) + 1;
  145.   ParmPacket.pUserParms = (ULONG)(dcp - p);
  146.   scp = pUserParms;
  147.   *dcp++ = strlen(pUserParms);
  148.   strcpy(dcp,scp);
  149.  }
  150.  cmd.api = STARTUSER;
  151.  cmd.len = ParmPacketLen;
  152.  
  153.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  154.  RmtSend(DEFAULT_HANDLE, pParmPacket, ParmPacketLen );
  155.  
  156.  RmtRecv(DEFAULT_HANDLE, &cmd, sizeof(cmd) );
  157.  ReturnPacketLen = cmd.len;
  158.  RmtRecv(DEFAULT_HANDLE, &ReturnPacket, ReturnPacketLen );
  159.  
  160.  *pSessionID   = ReturnPacket.SessionID;
  161.  *pProcessID   = ReturnPacket.ProcessID;
  162.  *pProcessType = ReturnPacket.ProcessType;
  163.  if( ReturnPacket.rc != 0 )
  164.   strcpy( pMsgBuf,ReturnPacket.ErrorBuf );
  165.  
  166.  return( ReturnPacket.rc );
  167. }
  168.  
  169. /*****************************************************************************/
  170. /* TxGoInit()                                                                */
  171. /*                                                                           */
  172. /* Description:                                                              */
  173. /*                                                                           */
  174. /*   Initialize the EXE file for debug.                                      */
  175. /*                                                                           */
  176. /* Parameters:                                                               */
  177. /*                                                                           */
  178. /*   pptb               -> to the ptrace buffer.                             */
  179. /*   pExecAddr          -> where to put the current exec address.            */
  180. /*   ppModuleLoadTable  where to put a ptr to the ModuleLoadTable.           */
  181. /*   pModuleTableLength where to put the length of the ModuleLoadtable.      */
  182. /*                                                                           */
  183. /* Return:                                                                   */
  184. /*                                                                           */
  185. /*   rc           trap code.                                                 */
  186. /*                                                                           */
  187. /* Assumptions:                                                              */
  188. /*                                                                           */
  189. /*****************************************************************************/
  190. APIRET TxGoInit( PtraceBuffer  *pptb,
  191.                  ULONG         *pExecAddr,
  192.                  UINT         **ppModuleLoadTable,
  193.                  int           *pModuleTableLength)
  194. {
  195.  COMMAND     cmd;
  196.  TXRX_GOINIT ParmPacket;
  197.  RET_GOINIT  ReturnPacket;
  198.  
  199.  /****************************************************************************/
  200.  /* - We will receive two separate transmissions.                            */
  201.  /* - One for the return packet and one for the module table.                */
  202.  /*                                                                          */
  203.  /****************************************************************************/
  204.  
  205.  ParmPacket.Pid = pptb->Pid;
  206.  ParmPacket.Sid = pptb->Tid;
  207.  
  208.  cmd.api = GOINIT;
  209.  cmd.len = sizeof(ParmPacket);
  210.  
  211.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  212.  RmtSend(DEFAULT_HANDLE, &ParmPacket, cmd.len );
  213.  
  214.  RmtRecv(DEFAULT_HANDLE, &cmd, sizeof(cmd) );
  215.  RmtRecv(DEFAULT_HANDLE, &ReturnPacket, cmd.len );
  216.  memcpy(pptb, &ReturnPacket.ptb, sizeof(PtraceBuffer) );
  217.  *pExecAddr = ReturnPacket.ExecAddr;
  218.  
  219.  RmtRecv(DEFAULT_HANDLE, &cmd, sizeof(cmd) );
  220.  *ppModuleLoadTable = Talloc(cmd.len);
  221.  RmtRecv(DEFAULT_HANDLE, *ppModuleLoadTable, cmd.len );
  222.  *pModuleTableLength = cmd.len;
  223.  return( ReturnPacket.rc );
  224. }
  225.  
  226. /*****************************************************************************/
  227. /* TxGoEntry()                                                               */
  228. /*                                                                           */
  229. /* Description:                                                              */
  230. /*                                                                           */
  231. /*   Run to the initial entry point.                                         */
  232. /*                                                                           */
  233. /* Parameters:                                                               */
  234. /*                                                                           */
  235. /*   pptb               -> to the ptrace buffer.                             */
  236. /*   pExecAddr          where to put the exec address.                       */
  237. /*   ppModuleLoadTable  where to put a ptr to the ModuleLoadTable.           */
  238. /*   pModuleTableLength where to put the length of the ModuleLoadtable.      */
  239. /*   ExecAddr           current EIP.                                         */
  240. /*   ExecFlags          exectuion control flags.                             */
  241. /*                                                                           */
  242. /* Return:                                                                   */
  243. /*                                                                           */
  244. /*   rc           trap code.                                                 */
  245. /*                                                                           */
  246. /* Assumptions:                                                              */
  247. /*                                                                           */
  248. /*   pptb->Pid == ProcessID                                                  */
  249. /*                                                                           */
  250. /*****************************************************************************/
  251. APIRET TxGoEntry( PtraceBuffer  *pptb,
  252.                   ULONG         *pExecAddr,
  253.                   UINT         **ppModuleLoadTable,
  254.                   int           *pModuleTableLength,
  255.                   ULONG         ExecAddr,
  256.                   int           ExecFlags)
  257. {
  258.  COMMAND     cmd;
  259.  TXRX_GOFAST ParmPacket;
  260.  RET_GOFAST  ReturnPacket;
  261.  
  262.  /****************************************************************************/
  263.  /* - We will receive two separate transmissions.                            */
  264.  /* - One for the return packet and one for the module table.                */
  265.  /*                                                                          */
  266.  /****************************************************************************/
  267.  
  268.  ParmPacket.ptb         = *pptb;
  269.  ParmPacket.ExecAddr    = ExecAddr;
  270.  ParmPacket.ExecFlags   = ExecFlags;
  271.  
  272.  cmd.api = GOENTRY;
  273.  cmd.len = sizeof(ParmPacket);
  274.  
  275.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  276.  RmtSend(DEFAULT_HANDLE, &ParmPacket, cmd.len );
  277.  
  278.  RmtRecv(DEFAULT_HANDLE, &cmd, sizeof(cmd) );
  279.  RmtRecv(DEFAULT_HANDLE, &ReturnPacket, cmd.len );
  280.  memcpy(pptb, &ReturnPacket.ptb, sizeof(PtraceBuffer) );
  281.  *pExecAddr = ReturnPacket.ExecAddr;
  282.  
  283.  RmtRecv(DEFAULT_HANDLE, &cmd, sizeof(cmd) );
  284.  *ppModuleLoadTable = Talloc(cmd.len);
  285.  RmtRecv(DEFAULT_HANDLE, *ppModuleLoadTable, cmd.len );
  286.  *pModuleTableLength = cmd.len;
  287.  return( ReturnPacket.rc );
  288.  
  289. }
  290. /*****************************************************************************/
  291. /* TxDefBrk()                                                                */
  292. /*                                                                           */
  293. /* Description:                                                              */
  294. /*                                                                           */
  295. /*   Define a break point in the x-server.                                   */
  296. /*                                                                           */
  297. /* Parameters:                                                               */
  298. /*                                                                           */
  299. /*   where      addr where to set the break point.                           */
  300. /*                                                                           */
  301. /* Return:                                                                   */
  302. /*                                                                           */
  303. /* Assumptions:                                                              */
  304. /*                                                                           */
  305. /*  It will work!                                                            */
  306. /*                                                                           */
  307. /*****************************************************************************/
  308. void TxDefBrk( ULONG where )
  309. {
  310.  COMMAND      cmd;
  311.  TXRX_DEFBRK  ParmPacket;
  312.  
  313.  ParmPacket.where = where;
  314.  cmd.api = DEFBRK;
  315.  cmd.len = sizeof(ParmPacket);
  316.  
  317.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  318.  RmtSend(DEFAULT_HANDLE, &ParmPacket, cmd.len );
  319. }
  320.  
  321. /*****************************************************************************/
  322. /* TxUndBrk()                                                                */
  323. /*                                                                           */
  324. /* Description:                                                              */
  325. /*                                                                           */
  326. /*   UnDefine a break point in the x-server.                                 */
  327. /*                                                                           */
  328. /* Parameters:                                                               */
  329. /*                                                                           */
  330. /*   where    addr of break point to undefine.                               */
  331. /*                                                                           */
  332. /* Return:                                                                   */
  333. /*                                                                           */
  334. /* Assumptions:                                                              */
  335. /*                                                                           */
  336. /*  It will work!                                                            */
  337. /*                                                                           */
  338. /*****************************************************************************/
  339. void TxUndBrk( ULONG where )
  340. {
  341.  COMMAND      cmd;
  342.  TXRX_UNDBRK  ParmPacket;
  343.  
  344.  ParmPacket.where = where;
  345.  cmd.api = UNDBRK;
  346.  cmd.len = sizeof(ParmPacket);
  347.  
  348.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  349.  RmtSend(DEFAULT_HANDLE, &ParmPacket, cmd.len );
  350. }
  351.  
  352. /*****************************************************************************/
  353. /* TxPutInBrk()                                                              */
  354. /*                                                                           */
  355. /* Description:                                                              */
  356. /*                                                                           */
  357. /*   Put in a breakpoint.                                                    */
  358. /*                                                                           */
  359. /* Parameters:                                                               */
  360. /*                                                                           */
  361. /*   where      addr where to put in the break point.                        */
  362. /*                                                                           */
  363. /* Return:                                                                   */
  364. /*                                                                           */
  365. /* Assumptions:                                                              */
  366. /*                                                                           */
  367. /*****************************************************************************/
  368. void TxPutInBrk( ULONG where )
  369. {
  370.  COMMAND       cmd;
  371.  TXRX_PUTINBRK ParmPacket;
  372.  
  373.  ParmPacket.where = where;
  374.  
  375.  cmd.api = PUTINBRK;
  376.  cmd.len = sizeof(ParmPacket);
  377.  
  378.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  379.  RmtSend(DEFAULT_HANDLE, &ParmPacket, cmd.len );
  380. }
  381.  
  382. /*****************************************************************************/
  383. /* TxPullOutBrk()                                                            */
  384. /*                                                                           */
  385. /* Description:                                                              */
  386. /*                                                                           */
  387. /*   Pull out a breakpoint.                                                  */
  388. /*                                                                           */
  389. /* Parameters:                                                               */
  390. /*                                                                           */
  391. /*   where      addr where to extact the break point.                        */
  392. /*                                                                           */
  393. /* Return:                                                                   */
  394. /*                                                                           */
  395. /* Assumptions:                                                              */
  396. /*                                                                           */
  397. /*****************************************************************************/
  398. void TxPullOutBrk( ULONG where )
  399. {
  400.  COMMAND         cmd;
  401.  TXRX_PULLOUTBRK ParmPacket;
  402.  
  403.  ParmPacket.where = where;
  404.  cmd.api = PULLOUTBRK;
  405.  cmd.len = sizeof(ParmPacket);
  406.  
  407.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  408.  RmtSend(DEFAULT_HANDLE, &ParmPacket, cmd.len );
  409. }
  410.  
  411. /*****************************************************************************/
  412. /* TxInsertAllBrk()                                                          */
  413. /*                                                                           */
  414. /* Description:                                                              */
  415. /*                                                                           */
  416. /*   Insert all the breakpoints.                                             */
  417. /*                                                                           */
  418. /* Parameters:                                                               */
  419. /*                                                                           */
  420. /* Return:                                                                   */
  421. /*                                                                           */
  422. /* Assumptions:                                                              */
  423. /*                                                                           */
  424. /*****************************************************************************/
  425. void TxInsertAllBrk()
  426. {
  427.  COMMAND      cmd;
  428.  
  429.  cmd.api = INSERTALLBRK;
  430.  cmd.len = 0;
  431.  
  432.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  433. }
  434.  
  435. /*****************************************************************************/
  436. /* TxRemoveAllBrk()                                                          */
  437. /*                                                                           */
  438. /* Description:                                                              */
  439. /*                                                                           */
  440. /*   Remove all the breakpoints.                                             */
  441. /*                                                                           */
  442. /* Parameters:                                                               */
  443. /*                                                                           */
  444. /* Return:                                                                   */
  445. /*                                                                           */
  446. /* Assumptions:                                                              */
  447. /*                                                                           */
  448. /*****************************************************************************/
  449. void TxRemoveAllBrk()
  450. {
  451.  COMMAND      cmd;
  452.  
  453.  cmd.api = REMOVEALLBRK;
  454.  cmd.len = 0;
  455.  
  456.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  457. }
  458.  
  459. /*****************************************************************************/
  460. /* TxGoStep()                                                                */
  461. /*                                                                           */
  462. /* Description:                                                              */
  463. /*                                                                           */
  464. /*   Step debuggee instruction(s).                                           */
  465. /*                                                                           */
  466. /* Parameters:                                                               */
  467. /*                                                                           */
  468. /*   pptb               -> to the ptrace buffer.                             */
  469. /*   pExecAddr          where to put the exec address.                       */
  470. /*   ppModuleLoadTable  where to put a ptr to the ModuleLoadTable.           */
  471. /*   pModuleTableLength where to put the length of the ModuleLoadtable.      */
  472. /*   ExecAddr           current EIP.                                         */
  473. /*   ExecAddrlo         start addr of the instructions for a source line.    */
  474. /*   ExecAddrhi         first addr past the instructions for a source line.  */
  475. /*   how                step qualifier such as OVERCALL or INTOCALL.         */
  476. /*   ExecFlags          execution control flags.                             */
  477. /*                                                                           */
  478. /* Return:                                                                   */
  479. /*                                                                           */
  480. /*   rc           trap code.                                                 */
  481. /*                                                                           */
  482. /* Assumptions:                                                              */
  483. /*                                                                           */
  484. /*   pptb->Pid == ProcessID                                                  */
  485. /*                                                                           */
  486. /*****************************************************************************/
  487. APIRET TxGoStep( PtraceBuffer  *pptb,
  488.                  ULONG         *pExecAddr,
  489.                  UINT         **ppModuleLoadTable,
  490.                  int           *pModuleTableLength,
  491.                  ULONG         ExecAddr,
  492.                  ULONG         ExecAddrlo,
  493.                  ULONG         ExecAddrhi,
  494.                  int           how,
  495.                  int           ExecFlags )
  496. {
  497.  COMMAND     cmd;
  498.  TXRX_GOSTEP ParmPacket;
  499.  RET_GOSTEP  ReturnPacket;
  500.  
  501.  /****************************************************************************/
  502.  /* - We will receive two separate transmissions.                            */
  503.  /* - One for the return packet and one for the module table.                */
  504.  /*                                                                          */
  505.  /****************************************************************************/
  506.  
  507.  ParmPacket.ptb         = *pptb;
  508.  ParmPacket.ExecAddr    = ExecAddr;
  509.  ParmPacket.ExecAddrlo  = ExecAddrlo;
  510.  ParmPacket.ExecAddrhi  = ExecAddrhi;
  511.  ParmPacket.how         = how;
  512.  ParmPacket.ExecFlags   = ExecFlags;
  513.  
  514.  cmd.api = GOSTEP;
  515.  cmd.len = sizeof(ParmPacket);
  516.  
  517.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  518.  RmtSend(DEFAULT_HANDLE, &ParmPacket, cmd.len );
  519.  
  520.  if(SerialParallel() == SERIAL)                                         /*919*/
  521.  {
  522.   SetExecutionFlag( TRUE );
  523.   ReleaseSerialMutex();
  524.   SerialConnect( DISCONNECT_WAIT, DbgGetProcessID(), _DBG, SendMsgToDbgQue );
  525.   RequestSerialMutex();
  526.   SetExecutionFlag( FALSE );
  527.  }
  528.  RmtRecv(DEFAULT_HANDLE, &cmd, sizeof(cmd) );
  529.  RmtRecv(DEFAULT_HANDLE, &ReturnPacket, cmd.len );
  530.  memcpy(pptb, &ReturnPacket.ptb, sizeof(PtraceBuffer) );
  531.  *pExecAddr = ReturnPacket.ExecAddr;
  532.  
  533.  RmtRecv(DEFAULT_HANDLE, &cmd, sizeof(cmd) );
  534.  *ppModuleLoadTable = Talloc(cmd.len);
  535.  RmtRecv(DEFAULT_HANDLE, *ppModuleLoadTable, cmd.len );
  536.  *pModuleTableLength = cmd.len;
  537.  return( ReturnPacket.rc );
  538.  
  539. }
  540.  
  541. /*****************************************************************************/
  542. /* TxGoFast()                                                                */
  543. /*                                                                           */
  544. /* Description:                                                              */
  545. /*                                                                           */
  546. /*   Run the debuggee.                                                       */
  547. /*                                                                           */
  548. /* Parameters:                                                               */
  549. /*                                                                           */
  550. /*   pptb               -> to the ptrace buffer.                             */
  551. /*   pExecAddr          where to put the exec address.                       */
  552. /*   ppModuleLoadTable  where to put a ptr to the ModuleLoadTable.           */
  553. /*   pModuleTableLength where to put the length of the ModuleLoadtable.      */
  554. /*   ExecAddr           current EIP.                                         */
  555. /*   ExecFlags          exectuion control flags.                             */
  556. /*                                                                           */
  557. /* Return:                                                                   */
  558. /*                                                                           */
  559. /*   rc           trap code.                                                 */
  560. /*                                                                           */
  561. /* Assumptions:                                                              */
  562. /*                                                                           */
  563. /*   pptb->Pid == ProcessID                                                  */
  564. /*                                                                           */
  565. /*****************************************************************************/
  566. APIRET TxGoFast( PtraceBuffer  *pptb,
  567.                  ULONG         *pExecAddr,
  568.                  UINT         **ppModuleLoadTable,
  569.                  int           *pModuleTableLength,
  570.                  ULONG         ExecAddr,
  571.                  int           ExecFlags)
  572. {
  573.  COMMAND     cmd;
  574.  TXRX_GOFAST ParmPacket;
  575.  RET_GOFAST  ReturnPacket;
  576.  
  577.  /****************************************************************************/
  578.  /* - We will receive two separate transmissions.                            */
  579.  /* - One for the return packet and one for the module table.                */
  580.  /*                                                                          */
  581.  /****************************************************************************/
  582.  
  583.  ParmPacket.ptb         = *pptb;
  584.  ParmPacket.ExecAddr    = ExecAddr;
  585.  ParmPacket.ExecFlags   = ExecFlags;
  586.  
  587.  cmd.api = GOFAST;
  588.  cmd.len = sizeof(ParmPacket);
  589.  
  590.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  591.  RmtSend(DEFAULT_HANDLE, &ParmPacket, cmd.len );
  592.  
  593.  if(SerialParallel() == SERIAL)                                         /*919*/
  594.  {
  595.   SetExecutionFlag( TRUE );
  596.   ReleaseSerialMutex();
  597.   SerialConnect( DISCONNECT_WAIT, DbgGetProcessID(), _DBG, SendMsgToDbgQue );
  598.   RequestSerialMutex();
  599.   SetExecutionFlag( FALSE );
  600.  }
  601.  RmtRecv(DEFAULT_HANDLE, &cmd, sizeof(cmd) );
  602.  RmtRecv(DEFAULT_HANDLE, &ReturnPacket, cmd.len );
  603.  memcpy(pptb, &ReturnPacket.ptb, sizeof(PtraceBuffer) );
  604.  *pExecAddr = ReturnPacket.ExecAddr;
  605.  
  606.  RmtRecv(DEFAULT_HANDLE, &cmd, sizeof(cmd) );
  607.  *ppModuleLoadTable = Talloc(cmd.len);
  608.  RmtRecv(DEFAULT_HANDLE, *ppModuleLoadTable, cmd.len );
  609.  *pModuleTableLength = cmd.len;
  610.  return( ReturnPacket.rc );
  611.  
  612. }
  613. /*****************************************************************************/
  614. /* TxDosDebug()                                                              */
  615. /*                                                                           */
  616. /* Description:                                                              */
  617. /*                                                                           */
  618. /*   Remote DosDebug API.                                                    */
  619. /*                                                                           */
  620. /* Parameters:                                                               */
  621. /*                                                                           */
  622. /*   pptb       -> to the DosDebug buffer.                                   */
  623. /*                                                                           */
  624. /* Return:                                                                   */
  625. /*                                                                           */
  626. /*   rc            rc from DosDebug on the remote debuggee.                  */
  627. /*                                                                           */
  628. /* Assumptions:                                                              */
  629. /*                                                                           */
  630. /*   none.                                                                   */
  631. /*                                                                           */
  632. /*****************************************************************************/
  633. APIRET APIENTRY TxDosDebug(PtraceBuffer *pptb)
  634. {
  635.  COMMAND       cmd;
  636.  TXRX_DOSDEBUG ParmPacket;
  637.  RET_DOSDEBUG  ReturnPacket;
  638.  long          DebugCmd;
  639.  
  640.  ParmPacket.ptb = *pptb;
  641.  
  642.  cmd.api  = DOSDEBUG;
  643.  cmd.cmd  = (UCHAR)pptb->Cmd;
  644.  cmd.len  = sizeof(ParmPacket.ptb);
  645.  DebugCmd = pptb->Cmd;
  646.  
  647.  if( DebugCmd == DBG_C_WriteMemBuf )
  648.  {
  649.   memcpy(ParmPacket.buffer,(char*)pptb->Buffer,pptb->Len);
  650.   cmd.len += pptb->Len;
  651.  }
  652.  
  653.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  654.  RmtSend(DEFAULT_HANDLE, &ParmPacket, cmd.len);
  655.  
  656.  RmtRecv(DEFAULT_HANDLE, &cmd, sizeof(cmd) );
  657.  RmtRecv(DEFAULT_HANDLE, &ReturnPacket, cmd.len );
  658.  
  659.  if( (ReturnPacket.rc == 0 ) &&
  660.      ( (DebugCmd == DBG_C_ReadMemBuf) || (DebugCmd == DBG_C_ThrdStat) )
  661.    )
  662.    memcpy((char*)pptb->Buffer,ReturnPacket.buffer,pptb->Len);
  663.  
  664.  memcpy(pptb,&ReturnPacket.ptb,sizeof(ReturnPacket.ptb));
  665.  
  666.  return( ReturnPacket.rc );
  667. }
  668.  
  669. /*****************************************************************************/
  670. /* TxGetThreadInfo()                                                         */
  671. /*                                                                           */
  672. /* Description:                                                              */
  673. /*                                                                           */
  674. /*   Get the thread info for the debuggee.                                   */
  675. /*                                                                           */
  676. /* Parameters:                                                               */
  677. /*                                                                           */
  678. /*   pBuffer    -> to the buffer to receive the info.                        */
  679. /*                                                                           */
  680. /* Return:                                                                   */
  681. /*                                                                           */
  682. /*   ntids      the number of threads.                                       */
  683. /*                                                                           */
  684. /* Assumptions:                                                              */
  685. /*                                                                           */
  686. /*   none.                                                                   */
  687. /*                                                                           */
  688. /*****************************************************************************/
  689. ULONG TxGetThreadInfo(THREADINFO *pBuffer)
  690. {
  691.  COMMAND cmd;
  692.  ULONG   ntids;
  693.  RET_GETTHREADINFO ReturnPacket;
  694.  
  695.  cmd.api  = GETTHREADINFO;
  696.  cmd.len  = 0;
  697.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  698.  RmtRecv(DEFAULT_HANDLE, &cmd, sizeof(cmd) );
  699.  RmtRecv(DEFAULT_HANDLE, &ReturnPacket, cmd.len );
  700.  
  701.  ntids = ReturnPacket.ntids;
  702.  memcpy(pBuffer, ReturnPacket.ti, ntids*sizeof(THREADINFO) );
  703.  return(ntids);
  704. }
  705.  
  706. /*****************************************************************************/
  707. /* TxFreezeThread()                                                          */
  708. /*                                                                           */
  709. /* Description:                                                              */
  710. /*                                                                           */
  711. /*   Freeze a thread.                                                        */
  712. /*                                                                           */
  713. /* Parameters:                                                               */
  714. /*                                                                           */
  715. /*   tid      thread id to freeze.                                           */
  716. /*                                                                           */
  717. /* Return:                                                                   */
  718. /*                                                                           */
  719. /*   void                                                                    */
  720. /*                                                                           */
  721. /* Assumptions:                                                              */
  722. /*                                                                           */
  723. /*   none.                                                                   */
  724. /*                                                                           */
  725. /*****************************************************************************/
  726. void  TxFreezeThread(ULONG tid )
  727. {
  728.  COMMAND cmd;
  729.  
  730.  cmd.api  = FREEZETHREAD;
  731.  cmd.len  = sizeof(tid);
  732.  
  733.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  734.  RmtSend(DEFAULT_HANDLE, &tid , cmd.len );
  735.  RmtRecv(DEFAULT_HANDLE, &cmd, sizeof(cmd) );
  736. }
  737. /*****************************************************************************/
  738. /* TxThawThread()                                                            */
  739. /*                                                                           */
  740. /* Description:                                                              */
  741. /*                                                                           */
  742. /*   Thaw a thread.                                                          */
  743. /*                                                                           */
  744. /* Parameters:                                                               */
  745. /*                                                                           */
  746. /*   tid      thread id to thaw.                                             */
  747. /*                                                                           */
  748. /* Return:                                                                   */
  749. /*                                                                           */
  750. /*   void                                                                    */
  751. /*                                                                           */
  752. /* Assumptions:                                                              */
  753. /*                                                                           */
  754. /*   none.                                                                   */
  755. /*                                                                           */
  756. /*****************************************************************************/
  757. void  TxThawThread(ULONG tid )
  758. {
  759.  COMMAND cmd;
  760.  
  761.  cmd.api  = THAWTHREAD;
  762.  cmd.len  = sizeof(tid);
  763.  
  764.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  765.  RmtSend(DEFAULT_HANDLE, &tid , cmd.len );
  766.  RmtRecv(DEFAULT_HANDLE, &cmd, sizeof(cmd) );
  767. }
  768.  
  769. /*****************************************************************************/
  770. /* TxGetCallStack()                                                          */
  771. /*                                                                           */
  772. /* Description:                                                              */
  773. /*                                                                           */
  774. /*   Thaw a thread.                                                          */
  775. /*                                                                           */
  776. /* Parameters:                                                               */
  777. /*                                                                           */
  778. /*   tid      thread id to thaw.                                             */
  779. /*                                                                           */
  780. /* Return:                                                                   */
  781. /*                                                                           */
  782. /*   void                                                                    */
  783. /*                                                                           */
  784. /* Assumptions:                                                              */
  785. /*                                                                           */
  786. /*   none.                                                                   */
  787. /*                                                                           */
  788. /*****************************************************************************/
  789. ULONG TxGetCallStack(STACK_PARMS *pparms,
  790.                      UCHAR       **ppActCSAtrs,
  791.                      UINT        **ppActFrames,
  792.                      UINT        **ppActFaddrs )
  793. {
  794.  COMMAND  cmd;
  795.  char     buffer[  (sizeof(RET_GETCALLSTACK)-1 )   +
  796.                    MAXAFRAMES*sizeof(UCHAR) +
  797.                    MAXAFRAMES*sizeof(UINT) +
  798.                    MAXAFRAMES*sizeof(UINT)
  799.                 ];
  800.  
  801.  ULONG    NActFrames;
  802.  UCHAR   *pActCSAtrs = NULL;
  803.  UINT    *pActFrames = NULL;
  804.  UINT    *pActFaddrs = NULL;
  805.  char    *p;
  806.  int      nbytes;
  807.  RET_GETCALLSTACK *pReturnPacket = (RET_GETCALLSTACK*)buffer;
  808.  
  809.  
  810.  cmd.api  = GETCALLSTACK;
  811.  cmd.len  = sizeof(STACK_PARMS);
  812.  
  813.  RmtSend(DEFAULT_HANDLE, &cmd  , sizeof(cmd) );
  814.  RmtSend(DEFAULT_HANDLE, pparms, cmd.len );
  815.  RmtRecv(DEFAULT_HANDLE, &cmd, sizeof(cmd) );
  816.  RmtRecv(DEFAULT_HANDLE, buffer, cmd.len );
  817.  
  818.  
  819.  NActFrames = pReturnPacket->NActFrames;
  820.  if( NActFrames )
  821.  {
  822.   pActCSAtrs = Talloc(NActFrames*sizeof(UCHAR));
  823.   pActFrames = Talloc(NActFrames*sizeof(UINT));
  824.   pActFaddrs = Talloc(NActFrames*sizeof(UINT));
  825.  
  826.   p = buffer + pReturnPacket->pActCSAtrs;
  827.   nbytes = NActFrames*sizeof(UCHAR);
  828.   memcpy(pActCSAtrs,p,nbytes);
  829.  
  830.   p = buffer + pReturnPacket->pActFrames;
  831.   nbytes = NActFrames*sizeof(UINT);
  832.   memcpy(pActFrames,p,nbytes);
  833.  
  834.   p = buffer + pReturnPacket->pActFaddrs;
  835.   nbytes = NActFrames*sizeof(UINT);
  836.   memcpy(pActFaddrs,p,nbytes);
  837.  
  838.   *ppActCSAtrs = pActCSAtrs;
  839.   *ppActFrames = pActFrames;
  840.   *ppActFaddrs = pActFaddrs;
  841.  }
  842.  return(NActFrames);
  843. }
  844. /*****************************************************************************/
  845. /* TxGetExeOrDllEntryOrExitPt()                                              */
  846. /*                                                                           */
  847. /* Description:                                                              */
  848. /*                                                                           */
  849. /*   Get the entry point for a dll or exe.                                   */
  850. /*                                                                           */
  851. /* Parameters:                                                               */
  852. /*                                                                           */
  853. /*   mte        module table handle of exe/dll.                              */
  854. /*                                                                           */
  855. /* Return:                                                                   */
  856. /*                                                                           */
  857. /*   EntryExitAddr  the entry/exit address from the exe/dll header.          */
  858. /*                                                                           */
  859. /* Assumptions:                                                              */
  860. /*                                                                           */
  861. /*   none.                                                                   */
  862. /*                                                                           */
  863. /*****************************************************************************/
  864. ULONG TxGetExeOrDllEntryOrExitPt( UINT mte )
  865. {
  866.  COMMAND cmd;
  867.  ULONG   LoadAddr;
  868.  
  869.  cmd.api  = GETEXEORDLLENTRY;
  870.  cmd.len  = sizeof(mte);
  871.  
  872.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  873.  RmtSend(DEFAULT_HANDLE, &mte , cmd.len );
  874.  RmtRecv(DEFAULT_HANDLE, &cmd, sizeof(cmd) );
  875.  RmtRecv(DEFAULT_HANDLE, &LoadAddr, cmd.len );
  876.  
  877.  return(LoadAddr);
  878. }
  879.  
  880. /*****************************************************************************/
  881. /* TxNormalQuit()                                                            */
  882. /*                                                                           */
  883. /* Description:                                                              */
  884. /*                                                                           */
  885. /*   Terminate the debuggee process.                                         */
  886. /*                                                                           */
  887. /* Parameters:                                                               */
  888. /*                                                                           */
  889. /*   AppTerminated  Flag indicating whether or not the app is terminated.    */
  890. /*   mte            module table handle of exe.                              */
  891. /*   EntryPt        exe entry point.                                         */
  892. /*                                                                           */
  893. /* Return:                                                                   */
  894. /*                                                                           */
  895. /*   rc             0 or 1                                                   */
  896. /*                                                                           */
  897. /* Assumptions:                                                              */
  898. /*                                                                           */
  899. /*   The application is either in the "DBG_N_ProcTerm" since the             */
  900. /*   app has executed a DosExit, or the state is unknown.                    */
  901. /*                                                                           */
  902. /*****************************************************************************/
  903. APIRET TxNormalQuit( int AppTerminated, UINT mte, ULONG EntryPt )
  904. {
  905.  COMMAND cmd;
  906.  TXRX_GETEXEORDLLENTRY ParmPacket;
  907.  APIRET  rc;
  908.  
  909.  ParmPacket.AppTerminated = AppTerminated;
  910.  ParmPacket.mte           = mte;
  911.  ParmPacket.EntryPt       = EntryPt;
  912.  
  913.  cmd.api  = NORMALQUIT;
  914.  cmd.len  = sizeof(ParmPacket);
  915.  
  916.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  917.  RmtSend(DEFAULT_HANDLE, &ParmPacket , cmd.len );
  918.  RmtRecv(DEFAULT_HANDLE, &cmd, sizeof(cmd) );
  919.  if(cmd.api != NORMALQUIT)
  920.  {
  921.   int   i;
  922.   char *cp = (char*)&cmd;
  923.  
  924.   for( i=1; i<=sizeof(cmd); i++,cp++)
  925.    printf("%c",*cp);
  926.  
  927.   AsyncFlushModem();
  928.   exit(0);
  929.  }
  930.  RmtRecv(DEFAULT_HANDLE, &rc, cmd.len );
  931.  
  932.  return(rc);
  933.  
  934. }
  935.  
  936. /*****************************************************************************/
  937. /* TxSetExecAddr()                                                           */
  938. /*                                                                           */
  939. /* Description:                                                              */
  940. /*                                                                           */
  941. /*   Set the exec address for the current thread.                            */
  942. /*                                                                           */
  943. /* Parameters:                                                               */
  944. /*                                                                           */
  945. /*   ExecAddr   Eip where we want to execute.                                */
  946. /*                                                                           */
  947. /* Return:                                                                   */
  948. /*                                                                           */
  949. /*   rc                                                                      */
  950. /*                                                                           */
  951. /* Assumptions:                                                              */
  952. /*                                                                           */
  953. /*   none.                                                                   */
  954. /*                                                                           */
  955. /*****************************************************************************/
  956. APIRET TxSetExecAddr( ULONG ExecAddr)
  957. {
  958.  COMMAND cmd;
  959.  APIRET  rc;
  960.  
  961.  cmd.api  = SETEXECADDR;
  962.  cmd.len  = sizeof(ExecAddr);
  963.  
  964.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  965.  RmtSend(DEFAULT_HANDLE, &ExecAddr , cmd.len );
  966.  RmtRecv(DEFAULT_HANDLE, &cmd, sizeof(cmd) );
  967.  RmtRecv(DEFAULT_HANDLE, &rc, cmd.len );
  968.  
  969.  return(rc);
  970. }
  971.  
  972. /*****************************************************************************/
  973. /* TxDefWps()                                                                */
  974. /*                                                                           */
  975. /* Description:                                                              */
  976. /*                                                                           */
  977. /*   Define the watch points in the server.                                  */
  978. /*                                                                           */
  979. /* Parameters:                                                               */
  980. /*                                                                           */
  981. /*   pRegs    -  ->array of watch point definitions.                         */
  982. /*   size     -  size of the block of debug register data.                   */
  983. /*                                                                           */
  984. /* Return:                                                                   */
  985. /*                                                                           */
  986. /*   rc                                                                      */
  987. /*                                                                           */
  988. /* Assumptions:                                                              */
  989. /*                                                                           */
  990. /*   none.                                                                   */
  991. /*                                                                           */
  992. /*****************************************************************************/
  993. void TxDefWps( void *pRegs,int size )
  994. {
  995.  COMMAND cmd;
  996.  TXRX_DEFWPS ParmPacket;
  997.  
  998.  cmd.api  = DEFWPS;
  999.  cmd.len  = sizeof(ParmPacket);
  1000.  
  1001.  memcpy(&ParmPacket.regs,pRegs,size);
  1002.  ParmPacket.size = size;
  1003.  
  1004.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  1005.  RmtSend(DEFAULT_HANDLE, &ParmPacket , cmd.len );
  1006.  RmtRecv(DEFAULT_HANDLE, &cmd, sizeof(cmd) );
  1007.  
  1008. }
  1009.  
  1010. /*****************************************************************************/
  1011. /* TxPutInWps()                                                              */
  1012. /*                                                                           */
  1013. /* Description:                                                              */
  1014. /*                                                                           */
  1015. /*   Put in watch points.                                                    */
  1016. /*                                                                           */
  1017. /* Parameters:                                                               */
  1018. /*                                                                           */
  1019. /*   pIndexes -  ->array that will receive the watch point indexes.          */
  1020. /*                                                                           */
  1021. /* Return:                                                                   */
  1022. /*                                                                           */
  1023. /* Assumptions:                                                              */
  1024. /*                                                                           */
  1025. /*   none.                                                                   */
  1026. /*                                                                           */
  1027. /*****************************************************************************/
  1028. void TxPutInWps( ULONG *pIndexes )
  1029. {
  1030.  COMMAND cmd;
  1031.  RET_PUTINWPS ReturnPacket;
  1032.  
  1033.  cmd.api  = PUTINWPS;
  1034.  cmd.len  = 0;
  1035.  
  1036.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  1037.  
  1038.  RmtRecv(DEFAULT_HANDLE, &cmd, sizeof(cmd) );
  1039.  RmtRecv(DEFAULT_HANDLE, &ReturnPacket,cmd.len);
  1040.  memcpy(pIndexes,ReturnPacket.indexes,cmd.len);
  1041. }
  1042.  
  1043. /*****************************************************************************/
  1044. /* TxPullOutWps()                                                            */
  1045. /*                                                                           */
  1046. /* Description:                                                              */
  1047. /*                                                                           */
  1048. /*   Pull out watch points.                                                  */
  1049. /*                                                                           */
  1050. /* Parameters:                                                               */
  1051. /*                                                                           */
  1052. /* Return:                                                                   */
  1053. /*                                                                           */
  1054. /* Assumptions:                                                              */
  1055. /*                                                                           */
  1056. /*   none.                                                                   */
  1057. /*                                                                           */
  1058. /*****************************************************************************/
  1059. void TxPullOutWps( void )
  1060. {
  1061.  COMMAND cmd;
  1062.  
  1063.  cmd.api  = PULLOUTWPS;
  1064.  cmd.len  = 0;
  1065.  
  1066.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  1067.  RmtRecv(DEFAULT_HANDLE, &cmd, sizeof(cmd) );
  1068. }
  1069.  
  1070. /*****************************************************************************/
  1071. /* TxGetMemoryBlock()                                                        */
  1072. /*                                                                           */
  1073. /* Description:                                                              */
  1074. /*                                                                           */
  1075. /*   Get a block of data.                                                    */
  1076. /*                                                                           */
  1077. /* Parameters:                                                               */
  1078. /*                                                                           */
  1079. /*   addr            pointer to address space in user's application.         */
  1080. /*   BytesWanted     number of bytes to copy from the user's application.    */
  1081. /*   pBytesObtained  pointer to number of bytes that were read in.           */
  1082. /*                                                                           */
  1083. /* Return:                                                                   */
  1084. /*                                                                           */
  1085. /*   pbytes          -> to block of bytes obtained.                          */
  1086. /*                                                                           */
  1087. /* Assumptions:                                                              */
  1088. /*                                                                           */
  1089. /*****************************************************************************/
  1090.  
  1091. static UCHAR *pbytes = NULL;
  1092. UCHAR *TxGetMemoryBlock( ULONG addr,int BytesWanted, int *pBytesObtained )
  1093. {
  1094.  COMMAND cmd;
  1095.  TXRX_GETDATABYTES  ParmPacket;
  1096.  RET_GETDATABYTES   ReturnPacket;
  1097.  
  1098.  cmd.api  = GETDATABYTES;
  1099.  cmd.len  = sizeof(ParmPacket);
  1100.  
  1101.  ParmPacket.addr        = addr;
  1102.  ParmPacket.BytesWanted = BytesWanted;
  1103.  
  1104.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  1105.  RmtSend(DEFAULT_HANDLE, &ParmPacket , cmd.len );
  1106.  RmtRecv(DEFAULT_HANDLE, &cmd, sizeof(cmd) );
  1107.  RmtRecv(DEFAULT_HANDLE, &ReturnPacket,cmd.len );
  1108.  
  1109.  *pBytesObtained = ReturnPacket.BytesObtained;
  1110.  
  1111.  if( pbytes )
  1112.  {
  1113.   Tfree(pbytes);
  1114.   pbytes = NULL;
  1115.  }
  1116.  
  1117.  if( ReturnPacket.BytesObtained != 0 )
  1118.  {
  1119.   pbytes = Talloc( ReturnPacket.BytesObtained );
  1120.   memcpy(pbytes,ReturnPacket.bytes,ReturnPacket.BytesObtained);
  1121.  }
  1122.  return(pbytes);
  1123. }
  1124.  
  1125. /*****************************************************************************/
  1126. /* TxGetMemoryBlocks()                                                       */
  1127. /*                                                                           */
  1128. /* Description:                                                              */
  1129. /*                                                                           */
  1130. /*   Get a some blocks of memory data.                                       */
  1131. /*                                                                           */
  1132. /* Parameters:                                                               */
  1133. /*                                                                           */
  1134. /*  pDefBlks         -> to an array of addresses and sizes of mem blocks.    */
  1135. /*  LengthOfDefBlk      length of the block defining the addrs & sizes.      */
  1136. /*                                                                           */
  1137. /* Return:                                                                   */
  1138. /*                                                                           */
  1139. /*  pMemBlks            -> to memory blocks.                                 */
  1140. /*                                                                           */
  1141. /* Assumptions:                                                              */
  1142. /*                                                                           */
  1143. /*  caller frees the pMemBlks allocation.                                    */
  1144. /*                                                                           */
  1145. /*****************************************************************************/
  1146. void *TxGetMemoryBlocks(void *pDefBlks, int   LengthOfDefBlk)
  1147. {
  1148.  COMMAND         cmd;
  1149.  int             LengthOfMemBlks;
  1150.  int            *pd;
  1151.  void           *pMemBlks;
  1152.  
  1153.  pd = (int *)pDefBlks;
  1154.  LengthOfMemBlks = *pd;
  1155.  
  1156.  cmd.api  = GETMEMBLKS;
  1157.  cmd.len  = LengthOfDefBlk;
  1158.  
  1159.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  1160.  RmtSend(DEFAULT_HANDLE, pDefBlks , cmd.len );
  1161.  
  1162.  /****************************************************************************/
  1163.  /* - Allocate a block of data to receive the result block.                  */
  1164.  /****************************************************************************/
  1165.  pMemBlks = Talloc( LengthOfMemBlks );
  1166.  
  1167.  RmtRecv(DEFAULT_HANDLE, &cmd, sizeof(cmd) );
  1168.  RmtRecv(DEFAULT_HANDLE, pMemBlks,cmd.len );
  1169.  
  1170.  return(pMemBlks);
  1171. }
  1172.  
  1173. /*****************************************************************************/
  1174. /* TxGetMemoryBlocks()                                                       */
  1175. /*                                                                           */
  1176. /* Description:                                                              */
  1177. /*                                                                           */
  1178. /*   Get a some blocks of memory data.                                       */
  1179. /*                                                                           */
  1180. /* Parameters:                                                               */
  1181. /*                                                                           */
  1182. /*  pExceptionMap    -> to an array of exception notify/nonotify specs.      */
  1183. /*  length              length of the map in bytes.                          */
  1184. /*                                                                           */
  1185. /* Return:                                                                   */
  1186. /*                                                                           */
  1187. /* Assumptions:                                                              */
  1188. /*                                                                           */
  1189. /*****************************************************************************/
  1190. void TxSetExceptions( UCHAR *pExceptionMap, int length )
  1191. {
  1192.  COMMAND         cmd;
  1193.  
  1194.  cmd.api  = SETXCPTNOTIFY;
  1195.  cmd.len  = length;
  1196.  
  1197.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  1198.  RmtSend(DEFAULT_HANDLE, pExceptionMap , cmd.len );
  1199.  
  1200.  RmtRecv(DEFAULT_HANDLE, &cmd, sizeof(cmd) );
  1201. }
  1202.  
  1203. /*****************************************************************************/
  1204. /* TxSetExecThread()                                                         */
  1205. /*                                                                           */
  1206. /* Description:                                                              */
  1207. /*                                                                           */
  1208. /*   Set the execution context to another thread.                            */
  1209. /*                                                                           */
  1210. /* Parameters:                                                               */
  1211. /*                                                                           */
  1212. /*   pExecAddr -> to address that will receive the flat execution address.   */
  1213. /*   pptb      -> to the ptrace buffer that we will fill in for the caller.  */
  1214. /*   tid          the thread we're establishing context in.                  */
  1215. /*                                                                           */
  1216. /* Return:                                                                   */
  1217. /*                                                                           */
  1218. /*   rc        0=>success                                                    */
  1219. /*             1=>failure                                                    */
  1220. /*                                                                           */
  1221. /* Assumption:                                                               */
  1222. /*                                                                           */
  1223. /*****************************************************************************/
  1224. APIRET TxSetExecThread(ULONG *pExecAddr,PtraceBuffer *pptb, UINT tid)
  1225. {
  1226.  COMMAND cmd;
  1227.  RET_SETEXECTHREAD ReturnPacket;
  1228.  
  1229.  cmd.api  = SETEXECTHREAD;
  1230.  cmd.len  = sizeof(tid);
  1231.  
  1232.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  1233.  RmtSend(DEFAULT_HANDLE, &tid , cmd.len );
  1234.  
  1235.  RmtRecv(DEFAULT_HANDLE, &cmd, sizeof(cmd) );
  1236.  RmtRecv(DEFAULT_HANDLE, &ReturnPacket, cmd.len );
  1237.  
  1238.  memcpy(pptb, &ReturnPacket.ptb, sizeof(PtraceBuffer) );
  1239.  *pExecAddr = ReturnPacket.ExecAddr;
  1240.  return( ReturnPacket.rc );
  1241. }
  1242.  
  1243. /*****************************************************************************/
  1244. /* TxWriteRegs()                                                             */
  1245. /*                                                                           */
  1246. /* Description:                                                              */
  1247. /*                                                                           */
  1248. /*   Write the registers to the application.                                 */
  1249. /*                                                                           */
  1250. /* Parameters:                                                               */
  1251. /*                                                                           */
  1252. /*   pExecAddr -> to address that will receive the flat execution address.   */
  1253. /*   pptb      -> to the ptrace buffer that we will fill in for the caller.  */
  1254. /*                                                                           */
  1255. /* Return:                                                                   */
  1256. /*                                                                           */
  1257. /*   rc        0=>success                                                    */
  1258. /*             1=>failure                                                    */
  1259. /*                                                                           */
  1260. /* Assumption:                                                               */
  1261. /*                                                                           */
  1262. /*****************************************************************************/
  1263. APIRET TxWriteRegs(ULONG *pExecAddr,PtraceBuffer *pptb)
  1264. {
  1265.  COMMAND cmd;
  1266.  RET_WRITEREGS ReturnPacket;
  1267.  
  1268.  cmd.api  = WRITEREGS;
  1269.  cmd.len  = sizeof(PtraceBuffer);
  1270.  
  1271.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  1272.  RmtSend(DEFAULT_HANDLE, pptb , cmd.len );
  1273.  
  1274.  RmtRecv(DEFAULT_HANDLE, &cmd, sizeof(cmd) );
  1275.  RmtRecv(DEFAULT_HANDLE, &ReturnPacket, cmd.len );
  1276.  
  1277.  *pExecAddr = ReturnPacket.ExecAddr;
  1278.  return( ReturnPacket.rc );
  1279. }
  1280.  
  1281. /*****************************************************************************/
  1282. /* TxGetCoRegs()                                                             */
  1283. /*                                                                           */
  1284. /* Description:                                                              */
  1285. /*                                                                           */
  1286. /*   Get the co-processor registers.                                         */
  1287. /*                                                                           */
  1288. /* Parameters:                                                               */
  1289. /*                                                                           */
  1290. /*   pExecAddr -> to address that will receive the flat execution address.   */
  1291. /*   pptb      -> to the ptrace buffer that we will fill in for the caller.  */
  1292. /*                                                                           */
  1293. /* Return:                                                                   */
  1294. /*                                                                           */
  1295. /*   rc        0=>success                                                    */
  1296. /*             1=>failure                                                    */
  1297. /*                                                                           */
  1298. /* Assumption:                                                               */
  1299. /*                                                                           */
  1300. /*****************************************************************************/
  1301. APIRET TxGetCoRegs(void *pCoproc_regs)
  1302. {
  1303.  COMMAND cmd;
  1304.  RET_GETCOREGS ReturnPacket;
  1305.  
  1306.  cmd.api  = GETCOREGS;
  1307.  cmd.len  = 0;
  1308.  
  1309.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  1310.  
  1311.  RmtRecv(DEFAULT_HANDLE, &cmd, sizeof(cmd) );
  1312.  RmtRecv(DEFAULT_HANDLE, &ReturnPacket, cmd.len );
  1313.  
  1314.  memcpy( pCoproc_regs, &ReturnPacket.coproc_regs,sizeof(COPROCESSORREGS) );
  1315.  return( ReturnPacket.rc );
  1316. }
  1317.  
  1318. /*****************************************************************************/
  1319. /* TxTerminateESP()                                                          */
  1320. /*                                                                           */
  1321. /* Description:                                                              */
  1322. /*                                                                           */
  1323. /*   Terminate the probe.                                                    */
  1324. /*                                                                           */
  1325. /* Parameters:                                                               */
  1326. /*                                                                           */
  1327. /* Return:                                                                   */
  1328. /*                                                                           */
  1329. /* Assumptions:                                                              */
  1330. /*                                                                           */
  1331. /*   none.                                                                   */
  1332. /*                                                                           */
  1333. /*****************************************************************************/
  1334. void TxTerminateESP( void )
  1335. {
  1336.  COMMAND cmd;
  1337.  
  1338.  cmd.api  = TERMINATEESP;
  1339.  cmd.len  = 0;
  1340.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  1341.  RmtRecv(DEFAULT_HANDLE, &cmd, sizeof(cmd) );
  1342. }
  1343.  
  1344. /*****************************************************************************/
  1345. /* TxSetEspRunOpts()                                                      919*/
  1346. /*                                                                           */
  1347. /* Description:                                                              */
  1348. /*                                                                           */
  1349. /*   Send run options to esp.                                                */
  1350. /*                                                                           */
  1351. /* Parameters:                                                               */
  1352. /*                                                                           */
  1353. /*  pEspRunOpts    ->to block of data containing flags and names             */
  1354. /*                                                                           */
  1355. /* Return:                                                                   */
  1356. /*                                                                           */
  1357. /* Assumptions:                                                              */
  1358. /*                                                                           */
  1359. /*****************************************************************************/
  1360. void TxSetEspRunOpts( ESP_RUN_OPTS *pEspRunOpts)
  1361. {
  1362.  COMMAND cmd;
  1363.  
  1364.  cmd.api = SETESPRUNOPTS;
  1365.  cmd.len = sizeof(ESP_RUN_OPTS) + pEspRunOpts->NameBlockSize - 1;
  1366.  
  1367.  RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
  1368.  RmtSend(DEFAULT_HANDLE, pEspRunOpts , cmd.len );
  1369. }
  1370.  
  1371. /*****************************************************************************/
  1372. /* TxSendCtrlBreak()                                                      917*/
  1373. /*                                                                           */
  1374. /* Description:                                                              */
  1375. /*                                                                           */
  1376. /*   Send a Ctrl-Break message to the probe.                                 */
  1377. /*                                                                           */
  1378. /* Parameters:                                                               */
  1379. /*                                                                           */
  1380. /*   handle      the connection handle we're sending the ctrl_break to.      */
  1381. /*                                                                           */
  1382. /* Return:                                                                   */
  1383. /*                                                                           */
  1384. /* Assumptions:                                                              */
  1385. /*                                                                           */
  1386. /*****************************************************************************/
  1387. void TxSendCtrlBreak( LHANDLE handle, USHORT pid )
  1388. {
  1389.  COMMAND cmd;
  1390.  
  1391.  cmd.api  = CTRL_BREAK;
  1392.  cmd.len  = sizeof(pid);
  1393.  
  1394.  RmtSend( handle, &cmd , sizeof(cmd) );
  1395.  RmtSend( handle, &pid , cmd.len     );
  1396. }
  1397.  
  1398. /*****************************************************************************/
  1399. /* TxStartQueListenThread()                                               919*/
  1400. /*                                                                           */
  1401. /* Description:                                                              */
  1402. /*                                                                           */
  1403. /*   Tell the probe to start up a thread to listen for messages              */
  1404. /*   coming from dbg. This thread is only applicable to parallel             */
  1405. /*   connections.                                                            */
  1406. /*                                                                           */
  1407. /* Parameters:                                                               */
  1408. /*                                                                           */
  1409. /* Return:                                                                   */
  1410. /*                                                                           */
  1411. /* Assumptions:                                                              */
  1412. /*                                                                           */
  1413. /*****************************************************************************/
  1414. void TxStartQueListenThread( void )
  1415. {
  1416.  COMMAND cmd;
  1417.  
  1418.  cmd.api  = START_QUE_LISTEN;
  1419.  cmd.len  = 0;
  1420.  
  1421.  RmtSend(DEFAULT_HANDLE, &cmd, sizeof(cmd) );
  1422. }
  1423.  
  1424. /*****************************************************************************/
  1425. /* TxStartEspQue()                                                        919*/
  1426. /*                                                                           */
  1427. /* Description:                                                              */
  1428. /*                                                                           */
  1429. /*   Tell the probe to start up a que to handle esp messages.                */
  1430. /*                                                                           */
  1431. /* Parameters:                                                               */
  1432. /*                                                                           */
  1433. /* Return:                                                                   */
  1434. /*                                                                           */
  1435. /* Assumptions:                                                              */
  1436. /*                                                                           */
  1437. /*****************************************************************************/
  1438. APIRET TxStartEspQue( void )
  1439. {
  1440.  COMMAND cmd;
  1441.  APIRET  rc = 0;
  1442.  
  1443.  cmd.api  = START_ESP_QUE;
  1444.  cmd.len  = 0;
  1445.  
  1446.  RmtSend(DEFAULT_HANDLE, &cmd, sizeof(cmd) );
  1447.  RmtRecv(DEFAULT_HANDLE, &cmd, sizeof(cmd) );
  1448.  RmtRecv(DEFAULT_HANDLE, &rc,  sizeof(rc) );
  1449.  return(rc);
  1450. }
  1451.  
  1452. /*****************************************************************************/
  1453. /* TxConnectEsp()                                                            */
  1454. /*                                                                           */
  1455. /* Description:                                                              */
  1456. /*                                                                           */
  1457. /*  Connect to the probe for the parameter pid and wait until we             */
  1458. /*  get verification that the message has been received and sent to          */
  1459. /*  the queue.                                                               */
  1460. /*                                                                           */
  1461. /* Parameters:                                                               */
  1462. /*                                                                           */
  1463. /*   handle   handle of the connection to the probe.                         */
  1464. /*   pid      process id of the probe.                                       */
  1465. /*                                                                           */
  1466. /* Return:                                                                   */
  1467. /*                                                                           */
  1468. /* Assumptions:                                                              */
  1469. /*                                                                           */
  1470. /*****************************************************************************/
  1471. void TxConnectEsp( LHANDLE handle, USHORT pid )
  1472. {
  1473.  COMMAND cmd;
  1474.  
  1475.  cmd.api = CONNECT_ESP;
  1476.  cmd.cmd = 0;
  1477.  cmd.len = sizeof(pid);
  1478.  
  1479.  RmtSend( handle, &cmd, sizeof(cmd) );
  1480.  RmtSend( handle, &pid, cmd.len );
  1481.  RmtRecv( handle, &cmd, sizeof(cmd) );
  1482. }
  1483.  
  1484. /*****************************************************************************/
  1485. /* TxSendKillListen()                                                        */
  1486. /*                                                                           */
  1487. /* Description:                                                              */
  1488. /*                                                                           */
  1489. /*   Send a command to kill the listen thread when connected via a           */
  1490. /*   parallel connection.                                                    */
  1491. /*                                                                           */
  1492. /* Parameters:                                                               */
  1493. /*                                                                           */
  1494. /*   handle      the connection handle we're sending the command to.         */
  1495. /*                                                                           */
  1496. /* Return:                                                                   */
  1497. /*                                                                           */
  1498. /* Assumptions:                                                              */
  1499. /*                                                                           */
  1500. /*****************************************************************************/
  1501. void TxSendKillListen( LHANDLE handle )
  1502. {
  1503.  COMMAND cmd;
  1504.  
  1505.  cmd.api  = KILL_LISTEN_THREAD;
  1506.  cmd.cmd  = 0;
  1507.  cmd.len  = 0;
  1508.  
  1509.  RmtSend( handle, &cmd , sizeof(cmd) );
  1510. }
  1511.  
  1512. /*****************************************************************************/
  1513. /* TxSelectSession()                                                         */
  1514. /*                                                                           */
  1515. /* Description:                                                              */
  1516. /*                                                                           */
  1517. /*   Select the debuggee session.                                            */
  1518. /*                                                                           */
  1519. /* Parameters:                                                               */
  1520. /*                                                                           */
  1521. /* Return:                                                                   */
  1522. /*                                                                           */
  1523. /* Assumption:                                                               */
  1524. /*                                                                           */
  1525. /*****************************************************************************/
  1526. void TxSelectSession( void )
  1527. {
  1528.  COMMAND cmd;
  1529.  
  1530.  cmd.api  = SELECT_SESSION;
  1531.  cmd.cmd  = 0;
  1532.  cmd.len  = 0;
  1533.  
  1534.  RmtSend( DEFAULT_HANDLE, &cmd, sizeof(cmd) );
  1535.  RmtRecv( DEFAULT_HANDLE, &cmd, sizeof(cmd) );
  1536. }
  1537.