eaw/libraries
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
Files
0d014802c5b3fe62cc73819b34739a2e43d26668
libraries/MDC/mdc_client.c
Philip Smart af833c09ee Initial upload
2019-11-18 00:29:48 +00:00

1467 lines
45 KiB
C
Executable File
Raw Blame History

/******************************************************************************
* Product: # # ###### ##### # ### ######
* ## ## # # # # # # # #
* # # # # # # # # # # #
* # # # # # # # # ######
* # # # # # # # # #
* # # # # # # # # # #
* # # ###### ##### ####### ####### ### ######
*
* File: mdc_client.c
* Description: MDC Generic communications routines.
*
* Version: %I%
* Dated: %D%
* Copyright: P. Smart, 1996-2019
*
* History: 1.0 - Initial Release.
*
******************************************************************************
* This source file is free software: you can redistribute it and#or modify
* it under the terms of the GNU General Public License as published
* by the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This source file is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
/* Bring in system header files.
*/
#if defined(SOLARIS)
#include <thread.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <stdarg.h>
#include <string.h>
/* Bring in Unix Library headers for TCP/IP communications.
*/
#include <ux.h>
/* Indicate that we are a C module for any header specifics.
*/
#define MDC_CLIENT_C
/* Bring in mdc header files.
*/
#include "mdc.h"
#include "mdc_common.h"
/******************************************************************************
* Function: _MDC_DataCB
* Description: This function is called back when data is received on any of
* the service connections
* Returns: void
******************************************************************************/
void _MDC_DataCB(UINT nChanId, UCHAR *szData, UINT nDataLen)
{
UCHAR *szFunc = "_MDC_DataCB";
UCHAR *szDeComData; /* pointer to decompressed data buffer */
CHSTATE eChanSt;
void (*pUserCB) (UINT, UCHAR *, UINT);
UCHAR *pszNAKErrStr; /* pointer to Error string in */
/* channel status structure */
/* Decompress
*/
szDeComData = Decompress(szData, &nDataLen);
if (szDeComData == NULL)
{
Lgr(LOG_DEBUG, szFunc, "Cannot malloc");
return;
}
/* Check if the data is a service request reply
*/
if (MDC.nPendSRChanId > 0 && nChanId == MDC.nPendSRChanId)
{
/* Reply received for service request
*/
MDC.cReplyType = * ((char *) szDeComData);
if (MDC.cReplyType == MDC_NAK)
{
Lgr(LOG_DEBUG, szFunc, "NAK received for service request");
_MDC_PrintErrMsg((szDeComData + 1), (nDataLen - 1));
}
MDC.nPendSRChanId = 0;
if (szDeComData != szData)
free(szDeComData);
return;
}
/* This is User Data, an ACK or a NAK
Get channel state
*/
if (_MDC_GetChState(nChanId, &eChanSt) != MDC_OK)
{
Lgr(LOG_DEBUG, szFunc,
"No status information for channel ID %d", nChanId);
if (szDeComData != szData)
free(szDeComData);
return;
}
switch(* ((char *) szDeComData))
{
case MDC_DATA:
if (eChanSt != IN_SEND_REQUEST)
{
Lgr(LOG_DEBUG, szFunc,
"Received data when in wrong state on channel %d", nChanId);
if (szDeComData != szData)
free(szDeComData);
return;
}
/* Get call back function address
*/
if (_MDC_GetUserCB(nChanId, &pUserCB) != MDC_OK)
{
Lgr(LOG_DEBUG, szFunc,
"_MDC_GetUserCB failed for channel ID %d", nChanId);
if (szDeComData != szData)
free(szDeComData);
return;
}
if (pUserCB == NULL)
{
Lgr(LOG_DEBUG, szFunc,
"User call back is NULL for channel ID %d", nChanId);
if (szDeComData != szData)
free(szDeComData);
return;
}
/* Call User call back.
Remove packet type character
*/
(*pUserCB) (nChanId, (szDeComData + 1), (nDataLen - 1));
break;
case MDC_ACK:
if (eChanSt != IN_SEND_REQUEST)
{
Lgr(LOG_DEBUG, szFunc,
"Received ACK when in wrong state on channel %d", nChanId);
if (szDeComData != szData)
free(szDeComData);
return;
}
if (_MDC_SetSRResult(nChanId, TRUE) != MDC_OK)
{
Lgr(LOG_DEBUG, szFunc,
"_MDC_SetSRResult failed for channel %d", nChanId);
if (szDeComData != szData)
free(szDeComData);
return;
}
if (_MDC_SetChState(nChanId, SEND_REQUEST_COMPLETE) != MDC_OK)
{
Lgr(LOG_DEBUG, szFunc,
"_MDC_SetChState failed for channel %d", nChanId);
if (szDeComData != szData)
free(szDeComData);
return;
}
break;
case MDC_NAK:
if (eChanSt != IN_SEND_REQUEST)
{
Lgr(LOG_DEBUG, szFunc,
"Received ACK when in wrong state on channel %d", nChanId);
if (szDeComData != szData)
free(szDeComData);
return;
}
/* Extract and save Error String
*/
if (_MDC_GetNAKErrStr(nChanId, &pszNAKErrStr) != MDC_OK)
{
Lgr(LOG_DEBUG, szFunc,
"_MDC_GetNAKErrStr failed for channel %d", nChanId);
if (szDeComData != szData)
free(szDeComData);
return;
}
strcpy((char *) pszNAKErrStr, (char *) (szDeComData + 1));
if (_MDC_SetSRResult(nChanId, FALSE) != MDC_OK)
{
Lgr(LOG_DEBUG, szFunc,
"_MDC_SetSRResult failed for channel %d", nChanId);
if (szDeComData != szData)
free(szDeComData);
return;
}
if (_MDC_SetChState(nChanId, SEND_REQUEST_COMPLETE) != MDC_OK)
{
Lgr(LOG_DEBUG, szFunc,
"_MDC_SetChState failed for channel %d", nChanId);
if (szDeComData != szData)
free(szDeComData);
return;
}
break;
default:
/* Unrecognised message type */
Lgr(LOG_DEBUG, szFunc,
"Unrecognised message type %c for channel ID %d",
eChanSt, nChanId);
break;
}
if (szDeComData != szData)
free(szDeComData);
}
/******************************************************************************
* Function: _MDC_CtrlCB
* Description: This function is called back when control information is received
* on any of the service connections
* Returns: void
******************************************************************************/
void _MDC_CtrlCB(int nType, ...)
{
/* Local variables.
*/
UINT nChanId;
UINT nPortNo;
ULNG lIPaddr;
va_list pArgs;
UCHAR *szFunc = "_MDC_CtrlCB";
/* Start var-arg list by making pArgs point to first arg in list.
*/
va_start(pArgs, nType);
/* What type of callback is it...?
*/
switch(nType)
{
/* A new connection has arrived.
*/
case SLC_NEWSERVICE:
nChanId = va_arg(pArgs, UINT);
nPortNo = va_arg(pArgs, UINT);
lIPaddr = va_arg(pArgs, ULNG);
/* Log link going down event for bug catching.
*/
Lgr(LOG_DEBUG, szFunc,
"New Service with client: nChanId=%d, nPortNo=%d, IP=%s",
nChanId, nPortNo, SL_HostIPtoString(lIPaddr));
break;
/* A connection has been made
*/
case SLC_CONNECT:
nChanId = va_arg(pArgs, UINT);
nPortNo = va_arg(pArgs, UINT);
lIPaddr = va_arg(pArgs, ULNG);
if (nChanId == MDC.nPendConChanId)
{
MDC.nPendConChanId = 0;
MDC.nLinkUp = TRUE;
Lgr(LOG_DEBUG, szFunc,
"Connected to client: nChanId=%d, nPortNo=%d, IP=%s",
nChanId, nPortNo, SL_HostIPtoString(lIPaddr));
} else
{
Lgr(LOG_DEBUG, szFunc,
"Rcvd unexpected connection: nChanId=%d, nPortNo=%d, IP=%s",
nChanId, nPortNo, SL_HostIPtoString(lIPaddr));
}
break;
/* Given connection has become temporarily unavailable.
*/
case SLC_LINKDOWN:
nChanId = va_arg(pArgs, UINT);
nPortNo = va_arg(pArgs, UINT);
lIPaddr = va_arg(pArgs, ULNG);
/* Log link going down event for bug catching.
*/
Lgr(LOG_DEBUG, szFunc,
"Link down to client: nChanId=%d, nPortNo=%d, IP=%s",
nChanId, nPortNo, SL_HostIPtoString(lIPaddr));
/* Reset flag to indicate that we dont have a connection.
*/
MDC.nLinkUp = FALSE;
break;
/* Given connection has died.
*/
case SLC_LINKFAIL:
nChanId = va_arg(pArgs, UINT);
nPortNo = va_arg(pArgs, UINT);
lIPaddr = va_arg(pArgs, ULNG);
/* Clean up for Channel ID
*/
if (SL_DelClient(nChanId) != R_OK)
{
Lgr(LOG_DEBUG, szFunc,
"SL_DelClient failed for Channel ID %d", nChanId);
}
/* Log link failure event for bug catching.
*/
Lgr(LOG_DEBUG, szFunc,
"Link closed to client: nChanId=%d, nPortNo=%d, IP=%s",
nChanId, nPortNo, SL_HostIPtoString(lIPaddr));
break;
default:
/* Log a message as this condition shouldnt occur.
*/
Lgr(LOG_DEBUG, szFunc, "Unrecognised message type (%d)", nType);
break;
}
/* Terminate var-arg list.
*/
va_end(pArgs);
}
/******************************************************************************
* Function: _MDC_SendPacket
* Description: Send a packet to a daemon
* Returns: MDC_OK or MDC_FAIL
******************************************************************************/
int _MDC_SendPacket(UINT nChanId, char cPacketType, UCHAR *psnzBuf, UINT nBuflen)
{
char *psnzPktMsgBuf; /* buffer for preparing message to be sent */
char *psnzComBuf; /* pointer to buffer containing compressed message */
UCHAR *szFunc = "_MDC_SendPacket";
UINT nlocalBufLen; /* Local buffer length variable */
nlocalBufLen = nBuflen + 1;
psnzPktMsgBuf = malloc(nlocalBufLen);
if (psnzPktMsgBuf == NULL)
{
Lgr(LOG_DEBUG, szFunc, "Cannot malloc");
return(MDC_FAIL);
}
/* Prepend packet type to service request data */
*psnzPktMsgBuf = cPacketType;
memcpy((psnzPktMsgBuf + 1), psnzBuf, (nlocalBufLen - 1));
/* Log message that we are sending to ease debugging.
*/
Lgr(LOG_DEBUG, szFunc, "Sending packet (Before Compress): Data=%s, Len=%d",
psnzPktMsgBuf, nlocalBufLen);
/* Compress packet to be sent
*/
psnzComBuf = Compress(psnzPktMsgBuf, &nlocalBufLen);
if (psnzComBuf == NULL)
{
Lgr(LOG_DEBUG, szFunc, "Cannot malloc for Compress");
free(psnzPktMsgBuf);
return(MDC_FAIL);
}
/* Log message that we are sending to ease debugging.
*/
Lgr(LOG_DEBUG, szFunc,
"Sending packet (After Compress): nChanId=%d, Data=%s, Len=%d",
nChanId, psnzPktMsgBuf, nlocalBufLen);
/* Send packet to the daemon */
if (SL_SendData(nChanId, (UCHAR *) psnzComBuf, nlocalBufLen) != R_OK)
{
Lgr(LOG_DEBUG, szFunc, "SL_SendData failed");
free(psnzPktMsgBuf);
if (psnzPktMsgBuf != psnzComBuf)
free(psnzComBuf);
return(MDC_FAIL);
}
free(psnzPktMsgBuf);
if (psnzPktMsgBuf != psnzComBuf)
free(psnzComBuf);
return(MDC_OK);
}
/******************************************************************************
* Function: _MDC_GetSrvRqtReply
* Description: Get reply to a service request packet
* Returns: MDC_OK or MDC_FAIL
******************************************************************************/
int _MDC_GetSrvRqtReply(UINT nChanId, char *pcPacketType)
{
/* Local variables.
*/
int nTotalTime;
UCHAR *szFunc = "_MDC_GetSrvRqtReply";
MDC.nPendSRChanId = nChanId;
/* Wait for the service request reply
*/
nTotalTime = 0;
while (MDC.nSrvReqTimeout > nTotalTime && MDC.nPendSRChanId != 0)
{
SL_Poll((ULNG) SR_SLEEP_TIME);
nTotalTime += SR_SLEEP_TIME;
}
if (MDC.nPendSRChanId != 0)
{
MDC.nPendSRChanId = 0;
Lgr(LOG_DEBUG, szFunc, "Timed out waiting for service request reply");
return(MDC_FAIL);
}
*pcPacketType = MDC.cReplyType;
return(MDC_OK);
}
/******************************************************************************
* Function: _MDC_CreateChStatus
* Description: Make a new Channel status structure and add to linked list
* Returns: MDC_OK or MDC_FAIL
******************************************************************************/
int _MDC_CreateChStatus(UINT nChanId) /* Channel ID */
{
UINT nLocalChanId = nChanId;
UCHAR *szFunc = "_MDC_CreateChStatus";
CHANSTATUS *psNewChanSt;
/* Check that there is not already an entry for the Channel ID
*/
if (FindItem(MDC.spChanDetHead, &nLocalChanId, NULL, NULL) != NULL)
{
Lgr(LOG_DEBUG, szFunc, "Channel ID %d already in use", nLocalChanId);
return(MDC_FAIL);
}
psNewChanSt = (CHANSTATUS *) malloc(sizeof(CHANSTATUS));
if (psNewChanSt == NULL)
{
Lgr(LOG_DEBUG, szFunc, "Cannot malloc");
return(MDC_FAIL);
}
psNewChanSt->nChanId = nLocalChanId;
psNewChanSt->State = MAKING_CONN;
psNewChanSt->UserDataCB = NULL;
if (AddItem(&MDC.spChanDetHead, &MDC.spChanDetTail, SORT_NONE, &nLocalChanId,
NULL, NULL, psNewChanSt) != R_OK)
{
Lgr(LOG_DEBUG, szFunc, "AddItem failed for Channel ID %d",
nLocalChanId);
return(MDC_FAIL);
}
return(MDC_OK);
}
/******************************************************************************
* Function: _MDC_DelChStatus
* Description: Delete an item from the Channel status linked list
* Returns: MDC_OK or MDC_FAIL
******************************************************************************/
int _MDC_DelChStatus(UINT nChanId) /* Channel ID */
{
UINT nLocalChanId = nChanId;
UCHAR *szFunc = "_MDC_DelChStatus";
CHANSTATUS *ChanSt;
if ((ChanSt = FindItem(MDC.spChanDetHead, &nLocalChanId, NULL, NULL)) == NULL)
{
Lgr(LOG_DEBUG, szFunc,
"FindItem failed: Channel ID %d not found", nLocalChanId);
return(MDC_FAIL);
}
if (DelItem(&MDC.spChanDetHead, &MDC.spChanDetTail, NULL, &nLocalChanId, NULL, NULL) != R_OK)
{
Lgr(LOG_DEBUG, szFunc,
"DelItem failed: Channel ID %d not found", nLocalChanId);
return(MDC_FAIL);
}
/* pds: 12/7/96. Ian forgot to tell the UX library that the channel had closed, so
* the following statement sends a request to UX to close the channel.
*/
SL_DelClient(nChanId);
free(ChanSt);
return(MDC_OK);
}
/******************************************************************************
* Function: _MDC_SetChState
* Description: Set Channel State to the given value
* Returns: MDC_OK or MDC_FAIL
******************************************************************************/
int _MDC_SetChState( UINT nChanId, /* Channel ID */
CHSTATE eNewState) /* New state */
{
UINT nLocalChanId = nChanId;
UCHAR *szFunc = "_MDC_SetChState";
CHANSTATUS *ChanSt;
if ((ChanSt = FindItem(MDC.spChanDetHead, &nLocalChanId, NULL, NULL)) == NULL)
{
Lgr(LOG_DEBUG, szFunc,
"FindItem failed: Channel ID %d not found", nLocalChanId);
return(MDC_FAIL);
}
ChanSt->State = eNewState;
return(MDC_OK);
}
/******************************************************************************
* Function: _MDC_SetSRResult
* Description: Set Channel Send Request result
* Returns: MDC_OK or MDC_FAIL
******************************************************************************/
int _MDC_SetSRResult( UINT nChanId, /* Channel ID */
UINT bResult) /* Send Request result */
{
UINT nLocalChanId = nChanId;
UCHAR *szFunc = "_MDC_SetSRResult";
CHANSTATUS *ChanSt;
if ((ChanSt = FindItem(MDC.spChanDetHead, &nLocalChanId, NULL, NULL)) == NULL)
{
Lgr(LOG_DEBUG, szFunc,
"FindItem failed: Channel ID %d not found", nLocalChanId);
return(MDC_FAIL);
}
ChanSt->bSendReqResult = bResult;
return(MDC_OK);
}
/******************************************************************************
* Function: _MDC_GetSRResult
* Description: Get Channel Send Request result
* Returns: MDC_OK or MDC_FAIL
******************************************************************************/
int _MDC_GetSRResult( UINT nChanId, /* Channel ID */
UINT *bResult) /* Send Request result */
{
UINT nLocalChanId = nChanId;
UCHAR *szFunc = "_MDC_GetSRResult";
CHANSTATUS *ChanSt;
if ((ChanSt = FindItem(MDC.spChanDetHead, &nLocalChanId, NULL, NULL)) == NULL)
{
Lgr(LOG_DEBUG, szFunc,
"FindItem failed: Channel ID %d not found", nLocalChanId);
return(MDC_FAIL);
}
*bResult = ChanSt->bSendReqResult;
return(MDC_OK);
}
/******************************************************************************
* Function: _MDC_SetUserCB
* Description: Set Send Request call back to the given value
* Returns: MDC_OK or MDC_FAIL
******************************************************************************/
int _MDC_SetUserCB( UINT nChanId, /* Channel ID */
void (*UserCB) (UINT, UCHAR *, UINT)) /* call back */
{
UINT nLocalChanId = nChanId;
UCHAR *szFunc = "_MDC_SetUserCB";
CHANSTATUS *ChanSt;
if ((ChanSt = FindItem(MDC.spChanDetHead, &nLocalChanId, NULL, NULL)) == NULL)
{
Lgr(LOG_DEBUG, szFunc,
"FindItem failed: Channel ID %d not found", nLocalChanId);
return(MDC_FAIL);
}
ChanSt->UserDataCB = UserCB;
return(MDC_OK);
}
/******************************************************************************
* Function: _MDC_GetChState
* Description: Get Channel State for a given channel
* Returns: MDC_OK or MDC_FAIL
******************************************************************************/
int _MDC_GetChState( UINT nChanId, /* Channel ID */
CHSTATE *eState) /* Channel state */
{
UINT nLocalChanId = nChanId;
UCHAR *szFunc = "_MDC_GetChState";
CHANSTATUS *ChanSt;
if ((ChanSt = FindItem(MDC.spChanDetHead, &nLocalChanId, NULL, NULL)) == NULL)
{
Lgr(LOG_DEBUG, szFunc,
"FindItem failed: Channel ID %d not found", nLocalChanId);
return(MDC_FAIL);
}
*eState = ChanSt->State;
return(MDC_OK);
}
/******************************************************************************
* Function: _MDC_GetNAKErrStr
* Description: Get pointer to NAK error string
* Returns: MDC_OK or MDC_FAIL
******************************************************************************/
int _MDC_GetNAKErrStr( UINT nChanId, /* Channel ID */
UCHAR **ppszErrStr) /* pointer to pointer to error string */
{
UINT nLocalChanId = nChanId;
UCHAR *szFunc = "_MDC_GetNAKErrStr";
CHANSTATUS *ChanSt;
if ((ChanSt = FindItem(MDC.spChanDetHead, &nLocalChanId, NULL, NULL)) == NULL)
{
Lgr(LOG_DEBUG, szFunc,
"FindItem failed: Channel ID %d not found", nLocalChanId);
return(MDC_FAIL);
}
*ppszErrStr = ChanSt->pszErrStr;
return(MDC_OK);
}
/******************************************************************************
* Function: _MDC_GetUserCB
* Description: Get User call back for the channel
* Returns: MDC_OK or MDC_FAIL
******************************************************************************/
int _MDC_GetUserCB( UINT nChanId, /* Channel ID */
void (**UserCB) (UINT, UCHAR *, UINT)) /* User call back */
{
UINT nLocalChanId = nChanId;
UCHAR *szFunc = "_MDC_GetUserCB";
CHANSTATUS *ChanSt;
if ((ChanSt = FindItem(MDC.spChanDetHead, &nLocalChanId, NULL, NULL)) == NULL)
{
Lgr(LOG_DEBUG, szFunc,
"FindItem failed: Channel ID %d not found", nLocalChanId);
return(MDC_FAIL);
}
*UserCB = ChanSt->UserDataCB;
return(MDC_OK);
}
/******************************************************************************
* Function: _MDC_PrintErrMsg
* Description: Print error message text
* Returns: MDC_OK or MDC_FAIL
******************************************************************************/
int _MDC_PrintErrMsg( UCHAR *psnzErrMsg, /* Error message none terminated */
UINT nBufLen) /* Buffer Length */
{
char *pszTmpBuf;
UCHAR *szFunc = "_MDC_PrintErrMsg";
pszTmpBuf = (char *) malloc(nBufLen + 1);
if (pszTmpBuf == NULL)
{
Lgr(LOG_DEBUG, szFunc, "Cannot malloc");
return(MDC_FAIL);
}
memcpy(pszTmpBuf, psnzErrMsg, nBufLen);
pszTmpBuf[nBufLen] = '\0';
Lgr(LOG_DEBUG, "", "Error Message: %s", pszTmpBuf);
free(pszTmpBuf);
return(MDC_OK);
}
/******************************************************************************
* Function: _MDC_WaitOnSndReq
* Description: Block until send request completes
* Returns: MDC_OK or MDC_FAIL
******************************************************************************/
int _MDC_WaitOnSndReq(UINT nChanId) /* Channel ID */
{
/* Local variables.
*/
UCHAR *szFunc = "_MDC_WaitOnSndReq";
int nTotalTime;
int bSendreqCom; /* Indicates if the send request is complete */
CHSTATE eChanSt;
/* Wait for send request to complete
*/
nTotalTime = 0;
bSendreqCom = FALSE;
while (MDC.nSndReqTimeout > nTotalTime && bSendreqCom == FALSE)
{
SL_Poll((ULNG) SNDREQ_SLEEP_TIME);
if (_MDC_GetChState(nChanId, &eChanSt) != MDC_OK)
{
Lgr(LOG_DEBUG, szFunc,
"No status information for channel ID %d", nChanId);
return(MDC_FAIL);
}
if(MDC.nLinkUp == FALSE)
{
Lgr(LOG_DEBUG, szFunc, "Link to daemon failed, aborting...");
return(MDC_FAIL);
}
if (eChanSt == SEND_REQUEST_COMPLETE)
bSendreqCom = TRUE;
nTotalTime += SNDREQ_SLEEP_TIME;
}
return(MDC_OK);
}
/******************************************************************************
* Function: MDC_SendRequest
* Description: Send a request to a driver
* Returns: MDC_OK or MDC_FAIL
******************************************************************************/
int MDC_SendRequest( UINT nChanId, /* I: Channel to send message on */
UCHAR *szData, /* I: Data to send */
UINT nDataLen, /* I: Length of data */
void (*DataCB) (UINT, UCHAR *, UINT))
/* I: call back function for data */
{
/* Local variables.
*/
UCHAR *szFunc = "MDC_SendRequest";
CHSTATE eCurrState; /* Current State for Channel ID */
/* If threading is enabled, then lock this function so that no other
* thread can enter.
*/
SINGLE_THREAD_LOCK
/* Check if in MDC Comms mode
*/
if (MDC.nMDCCommsMode == FALSE)
{
Lgr(LOG_DEBUG, szFunc, "Not in MDC Comms Mode");
THREAD_UNLOCK_RETURN(MDC_BADCONTEXT);
}
if (_MDC_GetChState(nChanId, &eCurrState) != MDC_OK)
{
Lgr(LOG_DEBUG, szFunc, "Cannot get status for channel %d", nChanId);
THREAD_UNLOCK_RETURN(MDC_FAIL);
}
if (eCurrState != IDLE)
{
Lgr(LOG_DEBUG, szFunc, "Channel state not IDLE");
THREAD_UNLOCK_RETURN(MDC_FAIL);
}
/* Store user call back function
*/
if (_MDC_SetUserCB(nChanId, DataCB) != MDC_OK)
{
Lgr(LOG_DEBUG, szFunc,
"_MDC_SetUserCB failed for Channel ID %d", nChanId);
THREAD_UNLOCK_RETURN(MDC_FAIL);
}
if (_MDC_SetChState(nChanId, IN_SEND_REQUEST) != MDC_OK)
{
Lgr(LOG_DEBUG, szFunc, "Cannot set channel status to IDLE");
THREAD_UNLOCK_RETURN(MDC_FAIL);
}
if (_MDC_SendPacket(nChanId, MDC_PREQ, szData, nDataLen) != MDC_OK)
{
Lgr(LOG_DEBUG, szFunc, "_MDC_SendPacket failed");
THREAD_UNLOCK_RETURN(MDC_FAIL);
}
/* Return success to caller as getting this far without hitch is success!
*/
THREAD_UNLOCK_RETURN(MDC_OK);
}
/******************************************************************************
* Function: MDC_GetResult
* Description: Wait for all replies to a send request and then return result
* Returns: MDC_OK or MDC_FAIL
******************************************************************************/
int MDC_GetResult( UINT nChanId, /* I: Channel ID */
UCHAR **ppszErrorMsg) /* O: Associated error message */
{
/* Local variables.
*/
UCHAR *szFunc = "MDC_GetResult";
CHSTATE eChanSt;
UINT bReqResult;
/* If threading is enabled, then lock this function so that no other
* thread can enter.
*/
SINGLE_THREAD_LOCK
/* Check if in MDC Comms mode
*/
if (MDC.nMDCCommsMode == FALSE)
{
Lgr(LOG_DEBUG, szFunc, "Not in MDC Comms Mode");
THREAD_UNLOCK_RETURN(MDC_BADCONTEXT);
}
if (_MDC_GetChState(nChanId, &eChanSt) != MDC_OK)
{
Lgr(LOG_DEBUG, szFunc,
"No status information for channel ID %d", nChanId);
THREAD_UNLOCK_RETURN(MDC_FAIL);
}
switch(eChanSt)
{
case SEND_REQUEST_COMPLETE:
break;
case IN_SEND_REQUEST:
/* Block until to Send Request Completes
*/
if(_MDC_WaitOnSndReq(nChanId) != MDC_OK)
{
Lgr(LOG_DEBUG, szFunc,
"_MDC_WaitOnSndReq failed for channel ID %d", nChanId);
THREAD_UNLOCK_RETURN(MDC_FAIL);
}
break;
default:
Lgr(LOG_DEBUG, szFunc,
"MDC_GetResult called when in state %c on channel %d",
eChanSt, nChanId);
THREAD_UNLOCK_RETURN(MDC_FAIL);
break;
}
if (_MDC_SetChState(nChanId, IDLE) != MDC_OK)
{
Lgr(LOG_DEBUG, szFunc,
"Cannot set channel state to IDLE for channel ID %d", nChanId);
THREAD_UNLOCK_RETURN(MDC_FAIL);
}
if (_MDC_GetSRResult(nChanId, &bReqResult) != MDC_OK)
{
Lgr(LOG_DEBUG, szFunc,
"_MDC_GetSRResult failed for channel ID %d", nChanId);
THREAD_UNLOCK_RETURN(MDC_FAIL);
}
if (_MDC_GetNAKErrStr(nChanId, ppszErrorMsg) != MDC_OK)
{
Lgr(LOG_DEBUG, szFunc,
"_MDC_GetNAKErrStr failed for channel %d", nChanId);
THREAD_UNLOCK_RETURN(MDC_FAIL);
}
if (bReqResult == FALSE)
THREAD_UNLOCK_RETURN(MDC_SNDREQNAK);
/* Return success to caller as getting this far without hitch is success!
*/
THREAD_UNLOCK_RETURN(MDC_OK);
}
/******************************************************************************
* Function: MDC_GetStatus
* Description: Returns a boolean that indicates whether the Send Request for
* given channel has completed.
* Returns: MDC_OK or MDC_FAIL
******************************************************************************/
int MDC_GetStatus( UINT nChanId, /* I: Channel ID */
UINT *bSndReqCom ) /* O: Indicates whether Send */
/* Request has completed */
{
UCHAR *szFunc = "MDC_GetStatus";
CHSTATE eChanSt;
/* If threading is enabled, then lock this function so that no other
* thread can enter.
*/
SINGLE_THREAD_LOCK
/* Check if in MDC Comms mode
*/
if (MDC.nMDCCommsMode == FALSE)
{
Lgr(LOG_DEBUG, szFunc, "Not in MDC Comms Mode");
THREAD_UNLOCK_RETURN(MDC_BADCONTEXT);
}
/* Call SL_Poll to process any outstanding messages
*/
SL_Poll(0);
if (_MDC_GetChState(nChanId, &eChanSt) != MDC_OK)
{
Lgr(LOG_DEBUG, szFunc,
"No status information for channel ID %d", nChanId);
THREAD_UNLOCK_RETURN(MDC_FAIL);
}
switch(eChanSt)
{
case SEND_REQUEST_COMPLETE:
*bSndReqCom = TRUE;
break;
case IN_SEND_REQUEST:
*bSndReqCom = FALSE;
break;
default:
Lgr(LOG_DEBUG, szFunc,
"MDC_GetStatus called when in state %c on channel %d",
eChanSt, nChanId);
THREAD_UNLOCK_RETURN(MDC_FAIL);
break;
}
/* Return success to caller as getting this far without hitch is success!
*/
THREAD_UNLOCK_RETURN(MDC_OK);
}
/******************************************************************************
* Function: MDC_CreateService
* Description: Create a connection to a daemon so that service requests can be
* issued
* Returns: Channel ID, or negative error code
******************************************************************************/
int MDC_CreateService( UCHAR *szHostName, /* I: Host for connect*/
UINT *nPortNo, /* I: Port host on */
SERVICEDETAILS *serviceDet ) /* I: Service details */
{
/* Statics.
*/
static int nProcessingFlag = FALSE;
/* Local variables.
*/
ULNG lIPAddr;
UINT nServicesPortNo;
UCHAR *szFunc = "MDC_CreateService";
int nTotalTime; /* total time waiting for connection to be made */
int ChanId;
char ReplyPktType;
/* If threading is enabled, then lock this function so that no other
* thread can enter.
*/
SINGLE_THREAD_LOCK
/* Check to see that we are not in the midst of a create service. If we are,
* get out!
*/
if( nProcessingFlag == TRUE )
{
Lgr(LOG_DEBUG, szFunc, "Not allowed to issue a %s from within a %s",
szFunc, szFunc);
THREAD_UNLOCK_RETURN(MDC_BADCONTEXT);
}
/* Check if in MDC comms mode
*/
if (MDC.nMDCCommsMode != TRUE)
{
Lgr(LOG_DEBUG, szFunc, "Not in MDC Comms Mode");
THREAD_UNLOCK_RETURN(MDC_BADCONTEXT);
}
if (MDC.nPendCon == TRUE)
{
Lgr(LOG_DEBUG, szFunc, "Already an outstanding service request");
THREAD_UNLOCK_RETURN(MDC_FAIL);
}
if (SL_GetIPaddr(szHostName, &lIPAddr) != R_OK)
{
Lgr(LOG_DEBUG, szFunc, "SL_GetIPaddr failed");
THREAD_UNLOCK_RETURN(MDC_FAIL);
}
/* OK, we are active, so set the processing flag to avoid being clobbered.
*/
nProcessingFlag = TRUE;
/* If the port number has not been given, then look one up.
*/
if (nPortNo == NULL)
{
if (SL_GetService(DEF_SERVICENAME, &nServicesPortNo) != R_OK)
{
Lgr(LOG_DEBUG, szFunc, "SL_GetService failed");
nProcessingFlag = FALSE;
THREAD_UNLOCK_RETURN(MDC_FAIL);
}
}
else
nServicesPortNo = *nPortNo;
if ((ChanId = SL_AddClient(nServicesPortNo, lIPAddr, szHostName,
_MDC_DataCB, _MDC_CtrlCB)) < 0)
{
Lgr(LOG_DEBUG, szFunc, "SL_AddClient failed");
nProcessingFlag = FALSE;
THREAD_UNLOCK_RETURN(MDC_FAIL);
}
/* Create Status structure for the new Channel
*/
if (_MDC_CreateChStatus(ChanId) != MDC_OK)
{
Lgr(LOG_DEBUG, szFunc, "_MDC_CreateChStatus failed");
nProcessingFlag = FALSE;
THREAD_UNLOCK_RETURN(MDC_FAIL);
}
MDC.nPendConChanId = (UINT) ChanId;
MDC.nPendCon = TRUE;
/* Wait for an indication that the connection has been made
*/
nTotalTime = 0;
while (MDC.nNewSrvTimeout > nTotalTime && MDC.nPendConChanId != 0)
{
SL_Poll((ULNG) CS_SLEEP_TIME);
nTotalTime += CS_SLEEP_TIME;
}
MDC.nPendCon = FALSE;
if (MDC.nPendConChanId != 0)
{
/* No connection made
*/
Lgr(LOG_DEBUG, szFunc,
"Timed out making connection to daemon at %s, port no %d",
szHostName, nServicesPortNo);
MDC.nPendConChanId = 0;
SL_DelClient((UINT) ChanId);
_MDC_DelChStatus((UINT) ChanId);
nProcessingFlag = FALSE;
THREAD_UNLOCK_RETURN(MDC_NODAEMON);
}
if (_MDC_SetChState((UINT) ChanId, IN_SERVICE_REQUEST) != MDC_OK)
{
Lgr(LOG_DEBUG, szFunc, "_MDC_SendData failed");
SL_DelClient((UINT) ChanId);
_MDC_DelChStatus((UINT) ChanId);
nProcessingFlag = FALSE;
THREAD_UNLOCK_RETURN(MDC_FAIL);
}
/* Send service request structure to the daemon
*/
if (_MDC_SendPacket((UINT) ChanId, MDC_INIT, (UCHAR *) serviceDet,
(UINT) sizeof(SERVICEDETAILS)) != MDC_OK)
{
Lgr(LOG_DEBUG, szFunc, "_MDC_SendData failed");
SL_DelClient((UINT) ChanId);
_MDC_DelChStatus((UINT) ChanId);
nProcessingFlag = FALSE;
THREAD_UNLOCK_RETURN(MDC_FAIL);
}
/* Get reply to service request.
*/
if (_MDC_GetSrvRqtReply((UINT) ChanId, &ReplyPktType) != MDC_OK)
{
Lgr(LOG_DEBUG, szFunc, "_MDC_GetSrvRqtReply failed");
SL_DelClient((UINT) ChanId);
_MDC_DelChStatus((UINT) ChanId);
nProcessingFlag = FALSE;
THREAD_UNLOCK_RETURN(MDC_FAIL);
}
if (ReplyPktType == MDC_NAK)
{
Lgr(LOG_DEBUG, szFunc, "NAK reply received for service request");
SL_DelClient((UINT) ChanId);
_MDC_DelChStatus((UINT) ChanId);
nProcessingFlag = FALSE;
THREAD_UNLOCK_RETURN(MDC_SERVICENAK);
}
if (_MDC_SetChState((UINT) ChanId, IDLE) != MDC_OK)
{
Lgr(LOG_DEBUG, szFunc, "Cannot set channel status to IDLE");
SL_DelClient((UINT) ChanId);
_MDC_DelChStatus((UINT) ChanId);
nProcessingFlag = FALSE;
THREAD_UNLOCK_RETURN(MDC_FAIL);
}
/* OK, finished processing successfully, so reset flag.
*/
nProcessingFlag = FALSE;
/* Get out, returning channel identifier of newly created service.
*/
THREAD_UNLOCK_RETURN(ChanId);
}
/******************************************************************************
* Function: MDC_SetTimeout
* Description: Function to program one of the system timeout values from the
* default to a user setting.
* Returns: MDC_OK - Setting changed.
* MDC_FAIL - Setting couldnt be changed, see error message.
******************************************************************************/
int MDC_SetTimeout( UCHAR *pszWhichTimeout, /* I: Timeout to set */
UINT nTimeoutValue, /* I: New value */
UCHAR *pszErrMsg ) /* O: Error message */
{
/* Local variables.
*/
UINT nReturn = MDC_OK;
UCHAR *szFunc = "MDC_SetTimeout";
/* If threading is enabled, then lock this function so that no other
* thread can enter.
*/
SINGLE_THREAD_LOCK
/* Simply compare the string given by the caller and match against known
* strings. If we get a match, then set the timeout value to that given.
*/
if(strcmp(pszWhichTimeout, NEW_SERVICE_TIMEOUT) == 0)
{
MDC.nNewSrvTimeout = nTimeoutValue;
} else
if(strcmp(pszWhichTimeout, SRV_REQ_TIMEOUT) == 0)
{
MDC.nSrvReqTimeout = nTimeoutValue;
} else
if(strcmp(pszWhichTimeout, SEND_REQ_TIMEOUT) == 0)
{
MDC.nSndReqTimeout = nTimeoutValue;
} else
{
nReturn = MDC_FAIL;
}
/* Exit with result code.
*/
THREAD_UNLOCK_RETURN(nReturn);
}
/******************************************************************************
* Function: MDC_CloseService
* Description: Close a service channel
* Returns: MDC_FAIL or MDC_OK or MDC_BADCONTEXT
******************************************************************************/
int MDC_CloseService( UINT nChanId ) /* I: Channel to close */
{
/* Local variables.
*/
UCHAR szTmpBuf[2];
UCHAR *szFunc = "MDC_CloseService";
/* If threading is enabled, then lock this function so that no other
* thread can enter.
*/
SINGLE_THREAD_LOCK
/* Prepare initial messages.
*/
sprintf(szTmpBuf, "%c", MDC_EXIT);
/* Check if in MDC Comms mode
*/
if (MDC.nMDCCommsMode == FALSE)
{
Lgr(LOG_DEBUG, szFunc, "Not in MDC Comms Mode");
THREAD_UNLOCK_RETURN(MDC_BADCONTEXT);
}
/* Send command to remote to initiate closedown procedures.
*/
if (SL_BlockSendData(nChanId, (UCHAR *) szTmpBuf, strlen(szTmpBuf) != R_OK))
{
Lgr(LOG_DEBUG, szFunc,
"Transmission of closedown message to client failed");
THREAD_UNLOCK_RETURN(MDC_FAIL);
}
/* Give the UX library a slice of CPU so that it can tidy up.
SL_Poll(MAX_TERMINATE_TIME);
*/
/* Delete the channel.
*/
if (_MDC_DelChStatus(nChanId) != MDC_OK)
{
Lgr(LOG_DEBUG, szFunc, "_MDC_DelChStatus failed for Channel ID %d",
nChanId);
THREAD_UNLOCK_RETURN(MDC_FAIL);
}
/* All done, return completion code to caller.
*/
THREAD_UNLOCK_RETURN(MDC_OK);
}
/******************************************************************************
* Function: MDC_Start
* Description: This is called to initialise the MDC Comms.
* Returns: MDC_FAIL or MDC_OK
******************************************************************************/
int MDC_Start( void )
{
/* Local variables.
*/
int ret;
UCHAR *szFunc = "MDC_Start";
/* If threading is enabled, then lock this function so that no other
* thread can enter.
*/
SINGLE_THREAD_LOCK
/* Setup logger mode.
*/
Lgr(LOG_CONFIG, LGM_STDOUT, LOG_MESSAGE, "");
if (_MDC_Init() != MDC_OK)
{
Lgr(LOG_DEBUG, szFunc, "_MDC_Init failed");
THREAD_UNLOCK_RETURN(MDC_FAIL);
}
/* Check if MDC Comms is already initialised
*/
if (MDC.nMDCCommsMode == TRUE)
{
Lgr(LOG_DEBUG, szFunc, "Already in MDC Comms Mode");
THREAD_UNLOCK_RETURN(MDC_BADCONTEXT);
}
/* Initialise UX comms
*/
if ((ret = SL_Init(MDC_CL_KEEPALIVE, (UCHAR *) NULL)) != R_OK)
{
Lgr(LOG_DEBUG, szFunc, "SL_Init failed");
THREAD_UNLOCK_RETURN(MDC_FAIL);
}
/* Now in MDC Comms Mode
*/
MDC.nMDCCommsMode = TRUE;
/* Return success to caller as getting this far without hitch is success!
*/
THREAD_UNLOCK_RETURN(MDC_OK);
}
/******************************************************************************
* Function: MDC_End
* Description: This is called to shutdown the MDC Comms.
* Returns: MDC_FAIL or MDC_OK
******************************************************************************/
int MDC_End( void )
{
/* Local variables.
*/
int ret;
CHANSTATUS *spChanDet;
LINKLIST *spNext;
UCHAR *szFunc = "MDC_End";
/* If threading is enabled, then lock this function so that no other
* thread can enter.
*/
SINGLE_THREAD_LOCK
/* Check if in MDC Comms mode
*/
if (MDC.nMDCCommsMode == FALSE)
{
Lgr(LOG_DEBUG, szFunc, "Not in MDC Comms Mode");
THREAD_UNLOCK_RETURN(MDC_BADCONTEXT);
}
/* Go through all current connections and close them if they are open.
*/
for(spChanDet=(CHANSTATUS *)StartItem(MDC.spChanDetHead, &spNext);
spChanDet != NULL;
spChanDet=(CHANSTATUS *)NextItem(&spNext))
{
/* Force closure of connection.
*/
MDC_CloseService(spChanDet->nChanId);
}
/* Final MDC termination tidy up.
*/
if (_MDC_Terminate() != MDC_OK)
{
Lgr(LOG_DEBUG, szFunc, "_SL_Terminate failed");
THREAD_UNLOCK_RETURN(MDC_FAIL);
}
/* Shutdown UX comms
*/
if ((ret = SL_Exit((UCHAR *) NULL)) != R_OK)
{
Lgr(LOG_DEBUG, szFunc, "SL_Exit failed");
THREAD_UNLOCK_RETURN(MDC_FAIL);
}
/* Exit MDC Comms Mode
*/
MDC.nMDCCommsMode = FALSE;
/* Return success to caller as weve got to the end without hitch.
*/
THREAD_UNLOCK_RETURN(MDC_OK);
}
/******************************************************************************
* Function: MDC_ChangeService
* Description: Change Service for an existing daemon connection
* Returns: MDC_OK, MDC_FAIL, MDC_NODAEMON, MDC_NOSERVICE, MDC_BADPARMS
******************************************************************************/
int MDC_ChangeService( UINT nChanId, /* I: Chan ID of srvc */
SERVICEDETAILS *serviceDet ) /* I: Service details */
{
/* Local variables.
*/
UCHAR *szFunc = "MDC_ChangeService";
char ReplyPktType;
CHSTATE eChanSt;
/* If threading is enabled, then lock this function so that no other
* thread can enter.
*/
SINGLE_THREAD_LOCK
/* Check if in MDC comms mode
*/
if (MDC.nMDCCommsMode != TRUE)
{
Lgr(LOG_DEBUG, szFunc, "Not in MDC Comms Mode");
THREAD_UNLOCK_RETURN(MDC_BADCONTEXT);
}
/* Check that in IDLE state on channel
*/
if (_MDC_GetChState(nChanId, &eChanSt) != MDC_OK)
{
Lgr(LOG_DEBUG, szFunc,
"No status information for channel ID %d", nChanId);
THREAD_UNLOCK_RETURN(MDC_FAIL);
}
if (eChanSt != IDLE)
{
Lgr(LOG_DEBUG, szFunc, "Channel ID %d not in idle state", nChanId);
THREAD_UNLOCK_RETURN(MDC_FAIL);
}
if (_MDC_SetChState(nChanId, IN_CHANGE_SERVICE) != MDC_OK)
{
Lgr(LOG_DEBUG, szFunc,
"Cannot set status to IN_CHANGE_SERVICE for channel ID %d",nChanId);
THREAD_UNLOCK_RETURN(MDC_FAIL);
}
/* Send service request structure to the daemon.
*/
if (_MDC_SendPacket((UINT)nChanId, MDC_CHANGE, (UCHAR *) serviceDet,
(UINT) sizeof(SERVICEDETAILS)) != MDC_OK)
{
Lgr(LOG_DEBUG, szFunc, "_MDC_SendPacket failed");
THREAD_UNLOCK_RETURN(MDC_FAIL);
}
/* Get reply to service request.
*/
if (_MDC_GetSrvRqtReply((UINT)nChanId, &ReplyPktType) != MDC_OK)
{
Lgr(LOG_DEBUG, szFunc, "_MDC_GetSrvRqtReply failed");
THREAD_UNLOCK_RETURN(MDC_FAIL);
}
if (ReplyPktType == MDC_NAK)
{
Lgr(LOG_DEBUG, szFunc, "NAK reply received for service request");
THREAD_UNLOCK_RETURN(MDC_SERVICENAK);
}
if (_MDC_SetChState((UINT)nChanId, IDLE) != MDC_OK)
{
Lgr(LOG_DEBUG, szFunc, "Cannot set channel status to IDLE");
THREAD_UNLOCK_RETURN(MDC_FAIL);
}
/* Return new channel id, shouldnt really have changed.
*/
THREAD_UNLOCK_RETURN(nChanId);
}
Reference in New Issue View Git Blame Copy Permalink