zbufsocklib.c

VXWORKS源代码

* is no longer in use by the TCP/IP network stack.  Applications can
* exploit this callback to receive notification that <buf> is free.
* If <freeRtn> is NULL, the routine functions normally, except that the 
* application has no way of being notified when <buf> is released by the
* network stack.  The free routine runs in the context of the task that last
* references the buffer.  This is typically either the context of tNetTask, 
* or the context of the caller's task.  Declare <freeRtn> as follows
* (using whatever name is convenient):
* .CS
*       void freeCallback
*           (
*           caddr_t     buf,    /@ pointer to user buffer @/
*           int         freeArg /@ user-provided argument to free routine @/
*           )
* .CE
*
* You may OR the following values into the <flags> parameter with this
* operation:
*
* .iP "MSG_OOB (0x1)" 26
* Out-of-band data.
* 
* .iP "MSG_DONTROUTE (0x4)"
* Send without using routing tables.
* .LP
* 
* VXWORKS AE PROTECTION DOMAINS
* Under VxWorks AE, you can call this function from within the kernel 
* protection domain only.  In addition, all arguments to this function can  
* reference only that data which is valid in the kernel protection domain. 
* This restriction does not apply under non-AE versions of VxWorks.  
*
* RETURNS:
* The number of bytes sent, or ERROR if the call fails.
*
* SEE ALSO
* zbufSockSend(), send()
*
*/

int zbufSockBufSend
    (
    int			s,		/* socket to send to */
    char *		buf,		/* pointer to data buffer */
    int		        bufLen,		/* number of bytes to send */
    VOIDFUNCPTR		freeRtn,	/* free routine callback */
    int			freeArg,	/* argument to free routine */
    int			flags		/* flags to underlying protocols */
    )
    {
    SOCK_FUNC * pSockFunc = sockFdtosockFunc(s);

    if (pSockFunc == NULL || pSockFunc->zbufRtn == NULL ||
	 (pSockFunc->zbufRtn)() == FALSE)
	{
	netErrnoSet (ENOTSUP);
	return (ERROR);
	}

    return ((pZbufSockFunc->bufSendRtn == NULL) ? ERROR :
	(pZbufSockFunc->bufSendRtn) (s, buf, bufLen, freeRtn, freeArg, flags));
    }

/*******************************************************************************
*
* zbufSockBufSendto - create a zbuf from a user message and send it to a UDP socket
*
* This routine creates a zbuf from the user buffer <buf>, and sends
* it to the datagram socket named by <to>.  The socket <s> is the
* sending socket.
*
* The user-provided free routine callback at <freeRtn> is called when <buf>
* is no longer in use by the UDP/IP network stack.  Applications can
* exploit this callback to receive notification that <buf> is free.
* If <freeRtn> is NULL, the routine functions normally, except that the 
* application has no way of being notified when <buf> is released by the
* network stack.  The free routine runs in the context of the task that last
* references the buffer.  This is typically either tNetTask context, 
* or the caller's task context.  Declare <freeRtn> as follows
* (using whatever name is convenient):
* .CS
*       void freeCallback
*           (
*           caddr_t     buf,    /@ pointer to user buffer @/
*           int         freeArg /@ user-provided argument to free routine @/
*           )
* .CE
*
* You may OR the following values into the <flags> parameter with this
* operation:
*
* .iP "MSG_OOB (0x1)" 26
* Out-of-band data.
* 
* .iP "MSG_DONTROUTE (0x4)"
* Send without using routing tables.
* .LP
* 
* VXWORKS AE PROTECTION DOMAINS
* Under VxWorks AE, you can call this function from within the kernel 
* protection domain only.  In addition, all arguments to this function can  
* reference only that data which is valid in the kernel protection domain. 
* This restriction does not apply under non-AE versions of VxWorks.  
*
* RETURNS:
* The number of bytes sent, or ERROR if the call fails.
*
* SEE ALSO
* zbufSockSendto(), sendto()
*/

int zbufSockBufSendto
    (
    int			s,		/* socket to send to */
    char *		buf,		/* pointer to data buffer */
    int		        bufLen,		/* number of bytes to send */
    VOIDFUNCPTR		freeRtn,	/* free routine callback */
    int			freeArg,	/* argument to free routine */
    int			flags,		/* flags to underlying protocols */
    struct sockaddr *	to,		/* recipient's address */
    int			tolen		/* length of <to> socket addr */
    )
    {
    SOCK_FUNC * pSockFunc = sockFdtosockFunc(s);

    if (pSockFunc == NULL || pSockFunc->zbufRtn == NULL ||
	(pSockFunc->zbufRtn)() == FALSE)
	{
	netErrnoSet (ENOTSUP);
	return (ERROR);
	}

    return ((pZbufSockFunc->bufSendtoRtn == NULL) ? ERROR :
	(pZbufSockFunc->bufSendtoRtn) (s, buf, bufLen, freeRtn, freeArg,
	flags, to, tolen));
    }

/*******************************************************************************
*
* zbufSockRecv - receive data in a zbuf from a TCP socket
*
* This routine receives data from a connection-based (stream) socket, and
* returns the data to the user in a newly created zbuf.
*
* The <pLen> parameter indicates the number of bytes requested by the caller.
* If the operation is successful, the number of bytes received is
* copied to <pLen>.
*
* You may OR the following values into the <flags> parameter with this
* operation:
*
* .iP "MSG_OOB (0x1)" 26
* Out-of-band data.
* 
* .iP "MSG_PEEK (0x2)"
* Return data without removing it from socket.
* .LP
* 
* Once the user application is finished with the zbuf, zbufDelete() should
* be called to return the zbuf memory buffer to the VxWorks network stack.
*
* VXWORKS AE PROTECTION DOMAINS
* Under VxWorks AE, you can call this function from within the kernel 
* protection domain only.  In addition, all arguments to this function can  
* reference only that data which is valid in the kernel protection domain. 
* This restriction does not apply under non-AE versions of VxWorks.  
*
* RETURNS:
* The zbuf ID of a newly created zbuf containing the received data,
* or NULL if the operation fails.
*
* SEE ALSO
* recv()
*/

ZBUF_ID zbufSockRecv
    (
    int			s,		/* socket to receive data from */
    int			flags,		/* flags to underlying protocols */
    int *		pLen		/* number of bytes requested/returned */
    )
    {
    SOCK_FUNC * pSockFunc = sockFdtosockFunc(s);

    if (pSockFunc == NULL || pSockFunc->zbufRtn == NULL || (pSockFunc->zbufRtn)() == FALSE)
	{
	netErrnoSet (ENOTSUP);
	return (NULL);
	}

    return ((pZbufSockFunc->recvRtn == NULL) ? NULL :
	(ZBUF_ID) (pZbufSockFunc->recvRtn) (s, flags, pLen));
    }

/*******************************************************************************
*
* zbufSockRecvfrom - receive a message in a zbuf from a UDP socket
*
* This routine receives a message from a datagram socket, and
* returns the message to the user in a newly created zbuf.
*
* The message is received regardless of whether the socket is connected.
* If <from> is nonzero, the address of the sender's socket is copied to it.
* Initialize the value-result parameter <pFromLen> to the size of
* the <from> buffer.  On return, <pFromLen> contains the actual size of the
* address stored in <from>.
*
* The <pLen> parameter indicates the number of bytes requested by the caller.
* If the operation is successful, the number of bytes received is
* copied to <pLen>.
*
* You may OR the following values into the <flags> parameter with this
* operation:
*
* .iP "MSG_OOB (0x1)" 26
* Out-of-band data.
* 
* .iP "MSG_PEEK (0x2)" 
* Return data without removing it from socket.  
* .LP
* 
* Once the user application is finished with the zbuf, zbufDelete() should
* be called to return the zbuf memory buffer to the VxWorks network stack.
*
* VXWORKS AE PROTECTION DOMAINS
* Under VxWorks AE, you can call this function from within the kernel 
* protection domain only.  In addition, all arguments to this function can  
* reference only that data which is valid in the kernel protection domain. 
* This restriction does not apply under non-AE versions of VxWorks.  
*
* RETURNS:
* The zbuf ID of a newly created zbuf containing the received message,
* or NULL if the operation fails.
*/

ZBUF_ID zbufSockRecvfrom
    (
    int			s,		/* socket to receive from */
    int			flags,		/* flags to underlying protocols */
    int *		pLen,		/* number of bytes requested/returned */
    struct sockaddr *	from,		/* where to copy sender's addr */
    int *		pFromLen	/* value/result length of <from> */
    )
    {
    SOCK_FUNC * pSockFunc = sockFdtosockFunc(s);

    if (pSockFunc == NULL || pSockFunc->zbufRtn == NULL ||
	(pSockFunc->zbufRtn)() == FALSE)
	{
	netErrnoSet (ENOTSUP);
	return (NULL);
	}

    return ((pZbufSockFunc->recvfromRtn == NULL) ? NULL :
	(ZBUF_ID) (pZbufSockFunc->recvfromRtn) (s, flags, pLen,
	from, pFromLen));
    }