mirror of
https://github.com/Mauler125/r5sdk.git
synced 2025-02-09 19:15:03 +01:00
b3a68ed095
DirtySDK (EA's Dirty Sockets library) will be used for the LiveAPI implementation, and depends on: EABase, EAThread.
330 lines
9.4 KiB
C
330 lines
9.4 KiB
C
/*H********************************************************************************/
|
||
/*!
|
||
\File testercomm.c
|
||
|
||
\Description
|
||
This module provides a communication layer between the host and the client.
|
||
Typical operations are SendLine() and GetLine(), which send and receive
|
||
lines of text, commands, debug output, etc. Each platform will implement
|
||
its own way of communicating – through files, debugger API calls, etc.
|
||
|
||
\Copyright
|
||
Copyright (c) 2005 Electronic Arts Inc.
|
||
|
||
\Version 03/23/2005 (jfrank) First Version
|
||
*/
|
||
/********************************************************************************H*/
|
||
|
||
/*** Include files ****************************************************************/
|
||
|
||
#include <stdio.h>
|
||
#include <string.h>
|
||
#include "DirtySDK/dirtysock.h"
|
||
#include "libsample/zmem.h"
|
||
#include "libsample/zlib.h"
|
||
#include "libsample/zlist.h"
|
||
#include "testerregistry.h"
|
||
#include "testercomm.h"
|
||
|
||
/*** Defines **********************************************************************/
|
||
|
||
/*** Type Definitions *************************************************************/
|
||
|
||
/*** Variables ********************************************************************/
|
||
|
||
/*** Private Functions ************************************************************/
|
||
|
||
/*** Public functions *************************************************************/
|
||
|
||
|
||
/*F********************************************************************************/
|
||
/*!
|
||
\Function TesterCommCreate
|
||
|
||
\Description
|
||
Create a tester host client communication module.
|
||
|
||
\Input None
|
||
|
||
\Output TesterCommT * - pointer to allocated module
|
||
|
||
\Version 03/23/2005 (jfrank)
|
||
*/
|
||
/********************************************************************************F*/
|
||
TesterCommT *TesterCommCreate(void)
|
||
{
|
||
TesterCommT *pState;
|
||
|
||
// create the module
|
||
pState = (TesterCommT *)ZMemAlloc(sizeof(TesterCommT));
|
||
ds_memclr((void *)pState, sizeof(TesterCommT));
|
||
pState->pInterface = (TesterCommInterfaceT *)ZMemAlloc(sizeof(TesterCommInterfaceT));
|
||
ds_memclr((void *)pState->pInterface, sizeof(TesterCommInterfaceT));
|
||
|
||
// create the lists
|
||
pState->pInputData = ZListCreate(TESTERCOMM_NUMCOMMANDS_MAX, sizeof(TesterCommDataT));
|
||
pState->pOutputData = ZListCreate(TESTERCOMM_NUMCOMMANDS_MAX, sizeof(TesterCommDataT));
|
||
|
||
// add this module to the registry
|
||
TesterRegistrySetPointer("COMM", pState);
|
||
|
||
// return the pointer
|
||
return(pState);
|
||
}
|
||
|
||
|
||
/*F********************************************************************************/
|
||
/*!
|
||
\Function TesterCommMessage
|
||
|
||
\Description
|
||
Send a message to the other side
|
||
|
||
\Input *pState - module state
|
||
\Input iMsgType - type of message to send (TESTER_MSGTYPE_XXX)
|
||
\Input *pMsgText - text of the message to send
|
||
|
||
\Output int32_t - 0 for success, error code otherwise
|
||
|
||
\Version 03/28/2005 (jfrank)
|
||
*/
|
||
/********************************************************************************F*/
|
||
int32_t TesterCommMessage(TesterCommT *pState, int32_t iMsgType, const char *pMsgText)
|
||
{
|
||
// check for error conditions
|
||
if ((pState == NULL) ||
|
||
(iMsgType <= 0) ||
|
||
(iMsgType >= TESTER_MSGTYPE_MAX) ||
|
||
(pMsgText == NULL))
|
||
{
|
||
return(-1);
|
||
}
|
||
|
||
ds_strnzcpy(pState->Message.strBuffer, pMsgText, sizeof(pState->Message.strBuffer));
|
||
pState->Message.iType = iMsgType;
|
||
return(ZListPushBack(pState->pOutputData, &pState->Message));
|
||
}
|
||
|
||
|
||
/*F********************************************************************************/
|
||
/*!
|
||
\Function TesterCommRegister
|
||
|
||
\Description
|
||
Register a callback for a particular type of message
|
||
|
||
\Input *pState - module state
|
||
\Input iMsgType - type of message register for (TESTER_MSGTYPE_XXX)
|
||
\Input *pCallback - callback to call when the message comes in
|
||
\Input *pParam - user pointer to pass to the callback
|
||
|
||
\Output int32_t - 0 for success, error code otherwise
|
||
|
||
\Version 03/29/2005 (jfrank)
|
||
*/
|
||
/********************************************************************************F*/
|
||
int32_t TesterCommRegister(TesterCommT *pState, int32_t iMsgType, TesterCommMsgCbT *pCallback, void *pParam)
|
||
{
|
||
// check error conditions
|
||
if ((pState == NULL) ||
|
||
(iMsgType <= 0) ||
|
||
(iMsgType >= TESTER_MSGTYPE_MAX))
|
||
{
|
||
return(-1);
|
||
}
|
||
|
||
// now register the callback
|
||
pState->MessageMap[iMsgType] = pCallback;
|
||
pState->pMessageMapUserData[iMsgType] = pParam;
|
||
return(0);
|
||
}
|
||
|
||
/*F********************************************************************************/
|
||
/*!
|
||
\Function TesterCommStatus
|
||
|
||
\Description
|
||
Get module status.
|
||
|
||
\Input *pState - module state
|
||
\Input iSelect - status selector
|
||
\Input iValue - selector specific
|
||
|
||
\Output int32_t - selector specific
|
||
|
||
\Version 10/31/2005 (jbrookes)
|
||
*/
|
||
/********************************************************************************F*/
|
||
int32_t TesterCommStatus(TesterCommT *pState, int32_t iSelect, int32_t iValue)
|
||
{
|
||
if (iSelect == 'inpt')
|
||
{
|
||
return(pState->bGotInput);
|
||
}
|
||
// unhandled
|
||
return(-1);
|
||
}
|
||
|
||
/*F********************************************************************************/
|
||
/*!
|
||
\Function TesterCommSuspend
|
||
|
||
\Description
|
||
Suspend the comm module. Service the files but don't
|
||
execute any commands until the Wake function is called,
|
||
|
||
\Input *pState - pointer to host client comm module
|
||
|
||
\Output None
|
||
|
||
\Version 04/07/2005 (jfrank)
|
||
*/
|
||
/********************************************************************************F*/
|
||
void TesterCommSuspend(TesterCommT *pState)
|
||
{
|
||
if(pState)
|
||
pState->uSuspended = 1;
|
||
}
|
||
|
||
|
||
/*F********************************************************************************/
|
||
/*!
|
||
\Function TesterCommWake
|
||
|
||
\Description
|
||
Wake the comm module to begin processing commands again.
|
||
|
||
\Input *pState - pointer to host client comm module
|
||
|
||
\Output None
|
||
|
||
\Version 04/07/2005 (jfrank)
|
||
*/
|
||
/********************************************************************************F*/
|
||
void TesterCommWake(TesterCommT *pState)
|
||
{
|
||
if(pState)
|
||
pState->uSuspended = 0;
|
||
}
|
||
|
||
|
||
/*F********************************************************************************/
|
||
/*!
|
||
\Function TesterCommDestroy
|
||
|
||
\Description
|
||
Destroy a tester host client communication module.
|
||
|
||
\Input *pState - pointer to host client comm module
|
||
|
||
\Output None
|
||
|
||
\Version 03/23/2005 (jfrank)
|
||
*/
|
||
/********************************************************************************F*/
|
||
void TesterCommDestroy(TesterCommT *pState)
|
||
{
|
||
if (pState)
|
||
{
|
||
// disconnect first, just in case
|
||
TesterCommDisconnect(pState);
|
||
ZListDestroy(pState->pInputData);
|
||
ZListDestroy(pState->pOutputData);
|
||
|
||
// delete this item from the registry
|
||
TesterRegistrySetPointer("COMM", NULL);
|
||
|
||
// now dump the memory
|
||
ZMemFree(pState->pInterface->pData);
|
||
ZMemFree(pState->pInterface);
|
||
ZMemFree(pState);
|
||
}
|
||
}
|
||
|
||
|
||
/*F********************************************************************************/
|
||
/*!
|
||
\Function TesterCommConnect
|
||
|
||
\Description
|
||
Connect the host client communication module.
|
||
|
||
\Input *pState - pointer to host client comm module
|
||
\Input *pParams - startup parameters
|
||
\Input bIsHost - TRUE=host, FALSE=client
|
||
|
||
\Output int32_t - 0 for success, error code otherwise
|
||
|
||
\Version 05/02/2005 (jfrank)
|
||
*/
|
||
/********************************************************************************F*/
|
||
int32_t TesterCommConnect(TesterCommT *pState, const char *pParams, uint32_t bIsHost)
|
||
{
|
||
// check for errors
|
||
if (pState == NULL)
|
||
return(-1);
|
||
if (pState->pInterface == NULL)
|
||
return(-1);
|
||
if (pState->pInterface->CommConnectFunc == NULL)
|
||
return(-1);
|
||
|
||
return(pState->pInterface->CommConnectFunc(pState, pParams, bIsHost));
|
||
}
|
||
|
||
/*F********************************************************************************/
|
||
/*!
|
||
\Function TesterCommUpdate
|
||
|
||
\Description
|
||
Give the host/client interface module some processor time. Call this
|
||
once in a while to pump the input and output pipes.
|
||
|
||
\Input *pState - module state
|
||
|
||
\Output int32_t - 0 for success, error code otherwise
|
||
|
||
\Version 05/02/2005 (jfrank)
|
||
*/
|
||
/********************************************************************************F*/
|
||
int32_t TesterCommUpdate(TesterCommT *pState)
|
||
{
|
||
// check for errors
|
||
if (pState == NULL)
|
||
return(-1);
|
||
if (pState->pInterface == NULL)
|
||
return(-1);
|
||
if (pState->pInterface->CommUpdateFunc == NULL)
|
||
return(-1);
|
||
|
||
return(pState->pInterface->CommUpdateFunc(pState));
|
||
}
|
||
|
||
|
||
/*F********************************************************************************/
|
||
/*!
|
||
\Function TesterCommDisconnect
|
||
|
||
\Description
|
||
Disconnect the host client communication module.
|
||
|
||
\Input *pState - pointer to host client comm module
|
||
|
||
\Output int32_t - 0=success, error code otherwise
|
||
|
||
\Version 05/02/2005 (jfrank)
|
||
*/
|
||
/********************************************************************************F*/
|
||
int32_t TesterCommDisconnect(TesterCommT *pState)
|
||
{
|
||
// check for errors
|
||
if (pState == NULL)
|
||
return(-1);
|
||
if (pState->pInterface == NULL)
|
||
return(-1);
|
||
if (pState->pInterface->CommDisconnectFunc == NULL)
|
||
return(-1);
|
||
|
||
return(pState->pInterface->CommDisconnectFunc(pState));
|
||
}
|
||
|