xdrwtx.c

VXWORKS源代码

	return (FALSE);
    if (!xdr_WTX_TOOL_DESC (xdrs, &objp->wtxToolDesc))
	return (FALSE);

    return (TRUE);
    }

/*******************************************************************************
*
* xdr_WTX_MSG_TS_INFO - target server information
*
*/

LOCAL bool_t xdr_WTX_MSG_TS_INFO 
    (
    XDR *		xdrs,
    WTX_MSG_TS_INFO *	objp,
    int			msgVersion
    )
    {
    if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
	return (FALSE);
    if (!xdr_WTX_TGT_LINK_DESC (xdrs, &objp->tgtLinkDesc))
	return (FALSE);
    if (!xdr_WTX_TGT_INFO (xdrs, &objp->tgtInfo, msgVersion))
	return (FALSE);
    if (!xdr_pointer (xdrs, (char **)&objp->pWtxToolDesc, 
		      sizeof (WTX_TOOL_DESC), xdr_WTX_TOOL_DESC))
	return (FALSE);
    if (!xdr_WRAPSTRING (xdrs, &objp->version))	
	return (FALSE);
    if (!xdr_WRAPSTRING (xdrs, &objp->userName))	
	return (FALSE);
    if (!xdr_WRAPSTRING (xdrs, &objp->startTime))	
	return (FALSE);
    if (!xdr_WRAPSTRING (xdrs, &objp->accessTime))	
	return (FALSE);
    if (!xdr_WRAPSTRING (xdrs, &objp->lockMsg))	
	return (FALSE);

    return (TRUE);
    }

/*******************************************************************************
*
* xdr_WTX_MSG_TS_INFO_V1 - target server information
*
*/

bool_t xdr_WTX_MSG_TS_INFO_V1
    (
    XDR *		xdrs,
    WTX_MSG_TS_INFO *	objp
    )
    {
    return xdr_WTX_MSG_TS_INFO (xdrs, objp, 1);
    }

/*******************************************************************************
*
* xdr_WTX_MSG_TS_INFO_V2 - target server information
*
*/

bool_t xdr_WTX_MSG_TS_INFO_V2
    (
    XDR *		xdrs,
    WTX_MSG_TS_INFO *	objp
    )
    {
    return xdr_WTX_MSG_TS_INFO (xdrs, objp, 2);
    }

/*******************************************************************************
*
* xdr_WTX_MSG_TS_LOCK - lock target server
*
*/

bool_t xdr_WTX_MSG_TS_LOCK 
    (
    XDR *	  xdrs,
    WTX_MSG_TS_LOCK * objp
    )
    {
    if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
	return (FALSE);
    if (!xdr_u_long (xdrs, (u_long *)&objp->lockType))	
	return (FALSE);

    return (TRUE);
    }

/*******************************************************************************
*
* xdr_WTX_MSG_TS_UNLOCK - unlock target server
*
*/

bool_t xdr_WTX_MSG_TS_UNLOCK 
    (
    XDR *	  xdrs,
    WTX_MSG_TS_UNLOCK * objp
    )
    {
    if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
	return (FALSE);
    if (!xdr_bool (xdrs, (bool_t *)&objp->force))	
	return (FALSE);

    return (TRUE);
    }

/*******************************************************************************
*
* xdr_MEM_COPY_ALLOC - allocate space and decode a MEM_COPY stucture
*
* This function decodes or frees the MEM_COPY structure protocol and
* allocate space to copy the data area referenced by the MEM_COPY
* structure.  The start address is handled by the source field and the size
* by numBytes. At the decoding time, the data are decoded and saved in a
* memory area allocated.  This function is needed to hanlde WTX_MEM_WRITE
* requests that use a target address as the destination pointer. In this
* case we must first copy the data into the target server before forwarding
* them to the target.
* 
* RETURNS:  TRUE if it succeeds, FALSE otherwise.
*/

bool_t xdr_MEM_COPY_ALLOC
    (
    XDR *	xdrs,
    WTX_MSG_MEM_COPY_DESC *	objp
    )
    {
    char * buff;	/* buffer where to decode data */

    if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
	return (FALSE);
    if (!xdr_u_long (xdrs, (u_long *)&objp->source))
	return (FALSE);
    if (!xdr_TGT_ADDR_T (xdrs, &objp->destination))
	return (FALSE);
    if (!xdr_u_long (xdrs, (u_long *)&objp->numBytes))
	return (FALSE);

    switch (xdrs->x_op) 
	{
    	case XDR_DECODE:
            {						 /* export block */
	    if ((buff = (char *)malloc (objp->numBytes)) == NULL)
	        return (FALSE);

	    if (!xdr_opaque (xdrs, (char *)buff, objp->numBytes))
	        return (FALSE);

            /* 
	     * Save the allocated buffer address in objp->source for
	     * later use by the target server.
	     */
	    objp->source = (u_int) buff;

	    return (TRUE);
	    }

    	case XDR_ENCODE:			
	    return (FALSE);			/* encoding not supported */

    	case XDR_FREE:				/* free memory */
	    return (TRUE);
	}

    return (FALSE);
    }

/*******************************************************************************
*
* xdr_MEM_WIDTH_COPY_ALLOC - allocate space and decode a MEM_COPY stucture
*
* This function decodes or frees the MEM_COPY structure protocol and
* allocate space to copy the data area referenced by the MEM_COPY
* structure.  The start address is handled by the source field and the size
* by numBytes. At the decoding time, the data are decoded and saved in a
* memory area allocated.  This function is needed to hanlde WTX_MEM_WRITE
* requests that use a target address as the destination pointer. In this
* case we must first copy the data into the target server before forwarding
* them to the target.
*
* RETURNS:  TRUE if it succeeds, FALSE otherwise.
*/

bool_t xdr_MEM_WIDTH_COPY_ALLOC
    (
    XDR *                             xdrs,
    WTX_MSG_MEM_WIDTH_COPY_DESC *     objp
    )
    {
    char * buff;        /* buffer where to decode data */

    if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
        return (FALSE);
    if (!xdr_u_long (xdrs, (u_long *)&objp->source))
        return (FALSE);
    if (!xdr_TGT_ADDR_T (xdrs, &objp->destination))
        return (FALSE);
    if (!xdr_u_long (xdrs, (u_long *)&objp->numBytes))
        return (FALSE);
    if (!xdr_u_char (xdrs, &objp->width))
        return (FALSE);

    switch (xdrs->x_op)
        {
        case XDR_DECODE:
            {                                            /* export block */
            if ((buff = (char *)malloc (objp->numBytes)) == NULL)
                return (FALSE);

            if (!xdr_opaque (xdrs, (char *)buff, objp->numBytes))
                return (FALSE);

            /*
             * Save the allocated buffer address in objp->source for
             * later use by the target server.
             */
            objp->source = (u_int) buff;

            return (TRUE);
            }

        case XDR_ENCODE:
            return (FALSE);                     /* encoding not supported */

        case XDR_FREE:                          /* free memory */
            return (TRUE);
        }

    return (FALSE);
    }

/*******************************************************************************
*
* xdr_WTX_MSG_TOOL_ID - WTX tool identifier
*
*/

bool_t xdr_WTX_MSG_TOOL_ID 
    (
    XDR *        	xdrs,
    WTX_MSG_TOOL_ID *	objp
    )
    {
    if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
	return (FALSE);

    return (TRUE);
    }

/*******************************************************************************
*
* xdr_WTX_MSG_KILL_DESC - WTX kill operation descriptor
*
*/

bool_t xdr_WTX_MSG_KILL_DESC 
    (
    XDR *        	xdrs,
    WTX_MSG_KILL_DESC * objp
    )
    {
    if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
	return (FALSE);

    if (!xdr_u_long (xdrs, (u_long *)&objp->request))
	return (FALSE);
    if (!xdr_WTX_VALUE (xdrs, &objp->arg))
	return (FALSE);

    return (TRUE);
    }

/*******************************************************************************
*
* xdr_WTX_EVENT - WTX
*
*/

bool_t xdr_WTX_EVENT 
    (
    XDR *        xdrs,
    WTX_EVENT * objp
    )
    {
    if (!xdr_enum (xdrs, (enum_t *)&objp->eventType))
	return (FALSE);
    if (!xdr_TGT_ARG_T (xdrs, &objp->eventArg))
	return (FALSE);

    return (TRUE);
    }

/*******************************************************************************
*
* xdr_WTX_ACTION - WTX
*
*/

bool_t xdr_WTX_ACTION 
    (
    XDR *        xdrs,
    WTX_ACTION * objp
    )
    {
    if (!xdr_enum (xdrs, (enum_t *)&objp->actionType))
	return (FALSE);
    if (!xdr_u_long (xdrs, (u_long *)&objp->actionArg))
	return (FALSE);
    if (!xdr_TGT_ADDR_T (xdrs, &objp->callRtn))
	return (FALSE);
    if (!xdr_TGT_ARG_T (xdrs, &objp->callArg))
	return (FALSE);

    return (TRUE);
    }

/*******************************************************************************
*
* xdr_WTX_CONTEXT - WTX context
*
*/

bool_t xdr_WTX_CONTEXT 
    (
    XDR *        xdrs,
    WTX_CONTEXT * objp
    )
    {
    if (!xdr_enum (xdrs, (enum_t *)&objp->contextType))
	return (FALSE);
    if (!xdr_WTX_CONTEXT_ID_T (xdrs, &objp->contextId))
	return (FALSE);

    return (TRUE);
    }

/*******************************************************************************
*
* xdr_WTX_MSG_CONTEXT - WTX context message
*
*/

bool_t xdr_WTX_MSG_CONTEXT 
    (
    XDR *        xdrs,
    WTX_MSG_CONTEXT * objp
    )
    {
    if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
	return (FALSE);
    if (!xdr_enum (xdrs, (enum_t *)&objp->contextType))
	return (FALSE);
    if (!xdr_WTX_CONTEXT_ID_T (xdrs, &objp->contextId))
	return (FALSE);

    return (TRUE);
    }

/*******************************************************************************
*
* xdr_WTX_EVTPT - WTX
*
*/

bool_t xdr_WTX_EVTPT 
    (
    XDR *        xdrs,
    WTX_EVTPT * objp
    )
    {
    if (!xdr_WTX_EVENT (xdrs, &objp->event))
	return (FALSE);
    if (!xdr_WTX_CONTEXT (xdrs, &objp->context))
	return (FALSE);
    if (!xdr_WTX_ACTION (xdrs, &objp->action))
	return (FALSE);

    return (TRUE);
    }

/*******************************************************************************
*
* xdr_WTX_MSG_EVTPT_DESC - WTX
*
*/

bool_t xdr_WTX_MSG_EVTPT_DESC 
    (
    XDR *        xdrs,
    WTX_MSG_EVTPT_DESC * objp
    )
    {
    if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
	return (FALSE);
    if (!xdr_WTX_EVTPT (xdrs, &objp->wtxEvtpt))
	return (FALSE);

    return (TRUE);
    }

/*******************************************************************************
*
* xdr_WTX_MSG_EVTPT_LIST - eventpoint list
*
*/

bool_t xdr_WTX_MSG_EVTPT_LIST 
    (
    XDR *        xdrs,
    WTX_MSG_EVTPT_LIST * objp
    )
    {
    if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
	return (FALSE);
    if (!xdr_u_long (xdrs, (u_long *)&objp->nEvtpt))
	return (FALSE);
    if (!xdr_array (xdrs, (char **)&objp->pEvtpt, (u_int *)&objp->nEvtpt, 
		    ~0, sizeof (WTX_EVTPT), xdr_WTX_EVTPT))

	return (FALSE);

    return (TRUE);
    }

/*******************************************************************************
*
* xdr_WTX_MEM_XFER - allocate space and decode a WTX_MEM_XFER stucture
*
* This function decodes or frees the WTX_MEM_XFER structure and
* allocate space to copy the data area referenced by the WTX_MEM_XFER
* structure.  The start address is handled by the source field and the size
* by numBytes. At the decoding time, the data are decoded and saved in a
* memory area allocated.  
* 
* RETURNS:  TRUE if it succeeds, FALSE otherwise.
*/

bool_t xdr_WTX_MEM_XFER
    (
    XDR *		xdrs,
    WTX_MEM_XFER *	objp
    )
    {
    char * buff;	/* buffer where to decode data */

    if (!xdr_u_long (xdrs, (u_long *)&objp->numBytes))
	return (FALSE);
    if (!xdr_u_long (xdrs, (u_long *)&objp->source))
	return (FALSE);
    if (!xdr_u_long (xdrs, (u_long *)&objp->destination))
	return (FALSE);

    switch (xdrs->x_op) 
	{
    	case XDR_DECODE:
            {						 /* export block */
	    if ((buff = (char *) malloc (objp->numBytes)) == NULL)
	        return (FALSE);

	    if (!xdr_opaque (xdrs, (char *) buff, objp->numBytes))
	        return (FALSE);

            /* 
	     * Save the allocated buffer address in objp->destination for
	     * later use by the client.
	     */

	    objp->source = (char *) buff;

	    return (TRUE);
	    }

    	case XDR_ENCODE:			
	    if (!xdr_opaque (xdrs, (char *) objp->source, objp->numBytes))
	        return (FALSE);
	    else
		return (TRUE);

    	case XDR_FREE:				/* free memory */
	    {
	    free (objp->source);
	    return (TRUE);
	    }
	}

    return (FALSE);
    }

/*******************************************************************************
*
* xdr_WTX_MSG_MEM_XFER_DESC - memory set descriptor
*
*/

bool_t xdr_WTX_MSG_MEM_XFER_DESC 
    (
    XDR *          xdrs,
    WTX_MSG_MEM_XFER_DESC * objp
    )
    {
    if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
	return (FALSE);
    if (!xdr_WTX_MEM_XFER (xdrs, &objp->memXfer))
	return (FALSE);

    return (TRUE);
    }

/*******************************************************************************
*
* xdr_WTX_MSG_REG_WRITE - code, decode or free the WTX_MSG_REG_WRITE structure. 
*
* This function codes, decodes or frees the WTX_MSG_REG_WRITE structure.
*
* RETURNS: TRUE if it succeeds, FALSE otherwise.
*/

bool_t xdr_WTX_MSG_REG_WRITE
    (
    XDR *	xdrs,
    WTX_MSG_REG_WRITE *	objp
    )
    {
    if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
	return (FALSE);
    if (!xdr_enum (xdrs, (enum_t *)&objp->regSetType))
	return (FALSE);

    if (!xdr_WTX_CONTEXT (xdrs, &objp->context))
	return (FALSE);

    if (!xdr_WTX_MEM_XFER (xdrs, &objp->memXfer))
	return (FALSE);

    return (TRUE);