wtxrpc.c

VxWorks BSP框架源代码包含头文件和驱动

    )
    {
    CLIENT *pClient;

    pClient = (CLIENT *) xid->transport;

    if (pClient == NULL)
	/* Nothing to do */
	return WTX_OK;

    if (pClient->cl_auth != NULL)
	auth_destroy (pClient->cl_auth);

    clnt_destroy (pClient);

    xid->transport = NULL;

    return (WTX_OK);
    }


/*******************************************************************************
*
* wtxRpcExchangeFree - free a exchange call result message
*
* This routine frees the memory allocated internally to the result message
* <pMsg> used in making the exchange service call <svcNum>.
*
* RETURNS: WTX_OK, or WTX_ERROR
*
* NOMANUAL
*/

WTX_ERROR_T wtxRpcExchangeFree
    (
    WTX_REQUEST	svcNum,		/* number of server service result to free */
    void *	pMsg		/* pointer to result message to free */
    )
    {
    if (svcNum > rpcSvcTableSize || (*rpcSvcTable)[svcNum] == NULL)
	return (WTX_ERR_EXCHANGE_REQUEST_UNSUPPORTED);

    (*rpcSvcTable)[svcNum]->xdrOut (&svrXdrs, pMsg);
 
    return (WTX_ERR_NONE);
    }



/*******************************************************************************
*
* wtxRpcExchange - do a WTX API call via the exchange mechanism
*
* This routine performs the exchange service call <svcNum> with in parameters
* pointed to by <pIn> and result (out) parameters pointed to by <pOut>. The
* status of the call is represented by the error code returned.  The result
* <pOut> may have memory allocated to it internally which can be freed by
* using wtxRpcExchangeFree().
*
* RETURNS: WTX_OK, or WTX_ERROR
*
* NOMANUAL
*/

STATUS wtxRpcExchange
    (
    WTX_XID	xid,		/* exchange handle */
    WTX_REQUEST	svcNum,		/* exchange service number */
    void *	pIn,		/* exchange service in args */
    void *	pOut		/* exchange service out args */
    )

    {
    enum clnt_stat	rpcStat; 
    WTX_ERROR_T		wtxStat;
    WTX_MSG_RESULT *	pMsgOut;
    CLIENT *		pClient;
    RPC_SERVICE	*	pService;
    struct timeval	timeout;


    pClient = (CLIENT *) xid->transport;
    if (pClient == NULL)
	WTX_EXCHANGE_RETURN (xid, WTX_ERR_EXCHANGE_NO_TRANSPORT, WTX_ERROR);

    /* Make sure the table has been initialized */

    if (rpcSvcTable == NULL)
	rpcSvcTableInstall ();

    if (svcNum > rpcSvcTableSize || (*rpcSvcTable)[svcNum] == NULL)
	WTX_EXCHANGE_RETURN (xid, WTX_ERR_EXCHANGE_REQUEST_UNSUPPORTED, 
			     WTX_ERROR);

    pService = (*rpcSvcTable)[svcNum];

    /* Construct a timeout struct on the fly for service request */

    timeout.tv_sec = xid->timeout / 1000;
    timeout.tv_usec = xid->timeout * 1000 - timeout.tv_sec * 1000000;

    rpcStat = clnt_call (pClient,
			 svcNum, 
			 pService->xdrIn, pIn,  
			 pService->xdrOut, pOut,  
			 timeout);

    wtxStat = rpcStatToError (rpcStat);

    if (wtxStat != WTX_ERR_NONE)
	{
	/* An RPC error occured. Free the result and return */
	clnt_freeres (pClient, pService->xdrOut, pOut);

	/* Handle case of RPC failing so badly we must disconnect */
	if (wtxStat == WTX_ERR_EXCHANGE_TRANSPORT_DISCONNECT)
	    wtxRpcExchangeDelete (xid);

	WTX_EXCHANGE_RETURN (xid, wtxStat, WTX_ERROR);
	}

    /* Sort cut for NULLPROC that doesn't return a proper WTX message result. */

    if (svcNum == NULLPROC)
	return WTX_OK;

    pMsgOut = (WTX_MSG_RESULT *) pOut;

    if (pMsgOut->wtxCore.errCode != OK)
	{
	UINT32 errCode;

	/* A service specific error occured. Free the result and return */

	errCode = pMsgOut->wtxCore.errCode;
	clnt_freeres (pClient, pService->xdrOut, pOut);
	WTX_EXCHANGE_RETURN (xid, errCode, WTX_ERROR);
	}

    return WTX_ERR_NONE;
    }


/*******************************************************************************
*
* rpcStatToError - convert an RPC status to a WTX error code.
* 
* This routine converts an RPC error status <callStat> to a WTX error code.
*
* RETURNS: the WTX error code or WTX_ERR_NONE if no error occured.
*
* NOMANUAL
*/

LOCAL WTX_ERROR_T rpcStatToError
    (
    enum clnt_stat	rpcStat		/* status from call */
    )

    {
    switch (rpcStat) 
	{
	case RPC_SUCCESS:
	    return WTX_ERR_NONE;	/* call succeeded */

	case RPC_CANTENCODEARGS:	/* can't encode arguments */
	case RPC_CANTDECODERES:		/* can't decode results */
	case RPC_CANTDECODEARGS:	/* decode arguments error */
	case RPC_SYSTEMERROR:		/* generic "other problem" */
	case RPC_UNKNOWNHOST:		/* unknown host name */
	case RPC_UNKNOWNPROTO:		/* unknown protocol -- 4.0 */
	case RPC_PMAPFAILURE:		/* the pmapper failed in its call */
	case RPC_PROGNOTREGISTERED:	/* remote program is not registered */
	case RPC_FAILED:
	    return WTX_ERR_EXCHANGE_TRANSPORT_ERROR;

	case RPC_PROCUNAVAIL:		/* procedure unavailable */
	    return WTX_ERR_EXCHANGE_REQUEST_UNSUPPORTED;

	case RPC_CANTSEND:		/* failure in sending call */
	case RPC_CANTRECV:		/* failure in receiving result */
	case RPC_VERSMISMATCH:		/* rpc versions not compatible */
	case RPC_AUTHERROR:		/* authentication error */
	case RPC_PROGUNAVAIL:		/* program not available */
	case RPC_PROGVERSMISMATCH:	/* program version mismatched */
	    return WTX_ERR_EXCHANGE_TRANSPORT_DISCONNECT;

	case RPC_TIMEDOUT:		/* call timed out */
	    return WTX_ERR_EXCHANGE_TIMEOUT;

	default:
	    return WTX_ERR_EXCHANGE;
	}
    
    }


/*******************************************************************************
*
* rpcSvcAdd - add a new service into the exchange service table
*
* This routine adds a new service with service number <svcNum> into the
* exchange service table.  The in and out XDR routines <xdrIn> and <xdrOut>
* are recorded in the table.
*
* RETURNS: OK, or ERROR.
*/

LOCAL STATUS rpcSvcAdd
    (
    UINT32	svcNum,
    xdrproc_t	xdrIn,
    xdrproc_t	xdrOut
    )

    {
    if (svcNum + 1 > rpcSvcTableSize)
	{
	RPC_SERVICE *(*newTable)[];

	/* Current table not big enough */

	newTable = calloc (svcNum + 1, sizeof (RPC_SERVICE *));
	if (newTable == NULL)
	    return ERROR;

	/* Copy and free the old one */

	if (rpcSvcTable != NULL)
	    {
	    memcpy (newTable, rpcSvcTable, 
		    rpcSvcTableSize * sizeof (RPC_SERVICE *));
	    free (rpcSvcTable);
	    }

	rpcSvcTable = newTable;
	rpcSvcTableSize = svcNum + 1;
	}
    
    (*rpcSvcTable)[svcNum] = malloc (sizeof (RPC_SERVICE));
    if  ((*rpcSvcTable)[svcNum] == NULL)
	/* No space for the new service description */
	return ERROR;

    (*rpcSvcTable)[svcNum]->xdrIn = xdrIn;
    (*rpcSvcTable)[svcNum]->xdrOut = xdrOut;

    return OK;
    }

    
/*******************************************************************************
*
* rpcSvcTableInstall - install initial table of service definitions
*
* This routine sets a the table that defines the XDR conversion functions
* for each available exchange service. No action is taken if this function
* is called more than once.
*
* RETURNS: OK, or ERROR
*/

LOCAL STATUS rpcSvcTableInstall (void)
    {
    if (rpcSvcTable != NULL)

	/* Already initialized */

	return (OK);

    /* Add the services to the table of available services */

    /* store the client XDRs */

    xdrmem_create (&svrXdrs, svrXdrsMCall, MCALL_MSG_SIZE, XDR_FREE);

    /* Ping or no-op service */

    rpcSvcAdd (NULLPROC, xdr_void, xdr_void);

    /* Registry services */

    rpcSvcAdd (WTX_INFO_Q_GET, 
	       xdr_WTX_MSG_WTXREGD_PATTERN, xdr_WTX_MSG_SVR_DESC_Q); 
    rpcSvcAdd (WTX_INFO_GET, xdr_WTX_MSG_PARAM, xdr_WTX_MSG_SVR_DESC); 
    rpcSvcAdd (WTX_REGISTER, xdr_WTX_MSG_SVR_DESC, xdr_WTX_MSG_SVR_DESC); 
    rpcSvcAdd (WTX_UNREGISTER, xdr_WTX_MSG_PARAM, xdr_WTX_MSG_RESULT); 

    /* Target server services */

    rpcSvcAdd (WTX_TOOL_ATTACH, xdr_WTX_MSG_TOOL_DESC, xdr_WTX_MSG_TOOL_DESC);
    rpcSvcAdd (WTX_TOOL_DETACH, xdr_WTX_MSG_TOOL_ID, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_TS_INFO_GET_V1, xdr_WTX_MSG_TOOL_ID, xdr_WTX_MSG_TS_INFO_V1);
    rpcSvcAdd (WTX_TS_INFO_GET_V2, xdr_WTX_MSG_TOOL_ID, xdr_WTX_MSG_TS_INFO_V2);
    rpcSvcAdd (WTX_TS_LOCK, xdr_WTX_MSG_TS_LOCK, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_TS_UNLOCK, xdr_WTX_MSG_TS_UNLOCK, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_TARGET_RESET, xdr_WTX_MSG_TOOL_ID, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_TARGET_ATTACH, xdr_WTX_MSG_TOOL_ID, xdr_WTX_MSG_RESULT);

#if 0 /* ELP */

    rpcSvcAdd (WTX_TARGET_PING, xdr_WTX_MSG_TOOL_ID, xdr_WTX_MSG_RESULT);
#endif

    rpcSvcAdd (WTX_CONTEXT_CREATE,
	       xdr_WTX_MSG_CONTEXT_DESC, xdr_WTX_MSG_CONTEXT);
    rpcSvcAdd (WTX_CONTEXT_KILL, xdr_WTX_MSG_CONTEXT, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_CONTEXT_SUSPEND, xdr_WTX_MSG_CONTEXT, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_CONTEXT_CONT, xdr_WTX_MSG_CONTEXT, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_CONTEXT_RESUME, xdr_WTX_MSG_CONTEXT, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_CONTEXT_STATUS_GET, xdr_WTX_MSG_CONTEXT, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_CONTEXT_STEP,
	       xdr_WTX_MSG_CONTEXT_STEP_DESC, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_EVENTPOINT_ADD, xdr_WTX_MSG_EVTPT_DESC, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_EVENTPOINT_DELETE, xdr_WTX_MSG_PARAM, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_EVENTPOINT_LIST, 
	       xdr_WTX_MSG_TOOL_ID, xdr_WTX_MSG_EVTPT_LIST);
    rpcSvcAdd (WTX_MEM_CHECKSUM, xdr_WTX_MSG_MEM_SET_DESC, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_MEM_DISASSEMBLE, xdr_WTX_MSG_DASM_DESC,
               xdr_WTX_MSG_DASM_INST_LIST);
    rpcSvcAdd (WTX_MEM_READ, 
	       xdr_WTX_MSG_MEM_READ_DESC, xdr_WTX_MSG_MEM_COPY_DESC);
    rpcSvcAdd (WTX_MEM_WRITE, xdr_WTX_MSG_MEM_COPY_DESC, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_MEM_SET, xdr_WTX_MSG_MEM_SET_DESC, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_MEM_SCAN, xdr_WTX_MSG_MEM_SCAN_DESC,	xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_MEM_MOVE, xdr_WTX_MSG_MEM_MOVE_DESC,	xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_MEM_ALLOC, xdr_WTX_MSG_PARAM, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_MEM_REALLOC,	xdr_WTX_MSG_MEM_BLOCK_DESC, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_MEM_ALIGN, xdr_WTX_MSG_MEM_BLOCK_DESC, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_MEM_ADD_TO_POOL,
	       xdr_WTX_MSG_MEM_BLOCK_DESC, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_MEM_FREE, xdr_WTX_MSG_PARAM, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_MEM_INFO_GET, xdr_WTX_MSG_TOOL_ID, xdr_WTX_MSG_MEM_INFO);
    rpcSvcAdd (WTX_REGS_GET, xdr_WTX_MSG_REG_READ, xdr_WTX_MSG_MEM_XFER_DESC);
    rpcSvcAdd (WTX_REGS_SET, xdr_WTX_MSG_REG_WRITE, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_OPEN, xdr_WTX_MSG_OPEN_DESC,	xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_VIO_READ, 
	       xdr_WTX_MSG_VIO_COPY_DESC, xdr_WTX_MSG_VIO_COPY_DESC);
    rpcSvcAdd (WTX_VIO_WRITE, xdr_WTX_MSG_VIO_COPY_DESC, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_CLOSE, xdr_WTX_MSG_PARAM, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_VIO_CTL, xdr_WTX_MSG_VIO_CTL_DESC, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_VIO_FILE_LIST, 
	       xdr_WTX_MSG_TOOL_ID, xdr_WTX_MSG_VIO_FILE_LIST);
    rpcSvcAdd (WTX_OBJ_MODULE_LOAD, 
	       xdr_WTX_MSG_LD_M_FILE_DESC, xdr_WTX_MSG_LD_M_FILE_DESC);
    rpcSvcAdd (WTX_OBJ_MODULE_UNLOAD, xdr_WTX_MSG_PARAM, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_OBJ_MODULE_LIST, 
	       xdr_WTX_MSG_TOOL_ID, xdr_WTX_MSG_MODULE_LIST);
    rpcSvcAdd (WTX_OBJ_MODULE_INFO_GET, 
	       xdr_WTX_MSG_MOD_NAME_OR_ID, xdr_WTX_MSG_MODULE_INFO);
    rpcSvcAdd (WTX_OBJ_MODULE_FIND, 
	       xdr_WTX_MSG_MOD_NAME_OR_ID, xdr_WTX_MSG_MOD_NAME_OR_ID);
    rpcSvcAdd (WTX_SYM_TBL_INFO_GET, 
	       xdr_WTX_MSG_PARAM, xdr_WTX_MSG_SYM_TBL_INFO);
    rpcSvcAdd (WTX_SYM_LIST_GET, 
	       xdr_WTX_MSG_SYM_MATCH_DESC, xdr_WTX_MSG_SYM_LIST);
    rpcSvcAdd (WTX_SYM_FIND, xdr_WTX_MSG_SYMBOL_DESC, xdr_WTX_MSG_SYMBOL_DESC);
    rpcSvcAdd (WTX_SYM_ADD, xdr_WTX_MSG_SYMBOL_DESC, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_SYM_REMOVE, xdr_WTX_MSG_SYMBOL_DESC, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_EVENT_GET, xdr_WTX_MSG_TOOL_ID, xdr_WTX_MSG_EVENT_DESC);
    rpcSvcAdd (WTX_REGISTER_FOR_EVENT, 
	       xdr_WTX_MSG_EVENT_REG_DESC, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_EVENT_ADD, xdr_WTX_MSG_EVENT_DESC, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_GOPHER_EVAL, xdr_WTX_MSG_PARAM, xdr_WTX_MSG_GOPHER_TAPE);
    rpcSvcAdd (WTX_FUNC_CALL, xdr_WTX_MSG_CONTEXT_DESC, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_DIRECT_CALL, xdr_WTX_MSG_CONTEXT_DESC, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_SERVICE_ADD, xdr_WTX_MSG_SERVICE_DESC, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_AGENT_MODE_SET, xdr_WTX_MSG_PARAM, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_AGENT_MODE_GET, xdr_WTX_MSG_TOOL_ID, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_CONSOLE_CREATE, 
	       xdr_WTX_MSG_CONSOLE_DESC, xdr_WTX_MSG_CONSOLE_DESC);
    rpcSvcAdd (WTX_CONSOLE_KILL, xdr_WTX_MSG_PARAM, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_OBJ_KILL, xdr_WTX_MSG_KILL_DESC, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_VIO_CHAN_GET, xdr_WTX_MSG_TOOL_ID, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_VIO_CHAN_RELEASE, xdr_WTX_MSG_PARAM, xdr_WTX_MSG_RESULT);

    /* WTX 2: new services */

    rpcSvcAdd (WTX_UNREGISTER_FOR_EVENT,
               xdr_WTX_MSG_EVENT_REG_DESC, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_CACHE_TEXT_UPDATE,
               xdr_WTX_MSG_MEM_BLOCK_DESC, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_MEM_WIDTH_READ,
               xdr_WTX_MSG_MEM_WIDTH_READ_DESC, xdr_WTX_MSG_MEM_WIDTH_COPY_DESC);
    rpcSvcAdd (WTX_MEM_WIDTH_WRITE,
               xdr_WTX_MSG_MEM_WIDTH_COPY_DESC, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_COMMAND_SEND,
               xdr_WTX_MSG_PARAM, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_OBJ_MODULE_CHECKSUM,
               xdr_WTX_MSG_MOD_NAME_OR_ID, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_EVENT_LIST_GET,
               xdr_WTX_MSG_PARAM, xdr_WTX_MSG_EVENT_LIST);
    rpcSvcAdd (WTX_OBJ_MODULE_LOAD_2,
               xdr_WTX_MSG_FILE_LOAD_DESC, xdr_WTX_MSG_LD_M_FILE_DESC);
    rpcSvcAdd (WTX_EVENTPOINT_ADD_2,
               xdr_WTX_MSG_EVTPT_DESC_2, xdr_WTX_MSG_RESULT);
    rpcSvcAdd (WTX_EVENTPOINT_LIST_GET,
               xdr_WTX_MSG_TOOL_ID, xdr_WTX_MSG_EVTPT_LIST_2);
    rpcSvcAdd (WTX_OBJ_MODULE_UNLOAD_2, xdr_WTX_MSG_MOD_NAME_OR_ID,
               xdr_WTX_MSG_RESULT);

    return (OK);
    }