socklib.c

VXWORKS源代码

* sender's socket is copied to it.  The value-result parameter <pFromLen>
* should be initialized to the size of the <from> buffer.  On return,
* <pFromLen> contains the actual size of the address stored in <from>.
*
* The maximum length of <buf> is subject to the limits on UDP buffer
* size; see the discussion of SO_RCVBUF in the setsockopt() manual
* entry.
*
* 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
*
* RETURNS
* The number of number of bytes received, or ERROR if the call fails.
*
* SEE ALSO
* setsockopt()
*/

int recvfrom
    (
    FAST int             s,         /* socket to receive from */
    FAST char            *buf,      /* pointer to data buffer */
    FAST int             bufLen,    /* length of buffer */
    FAST int             flags,     /* flags to underlying protocols */
    FAST struct sockaddr *from,     /* where to copy sender's addr */
    FAST int             *pFromLen  /* value/result length of <from> */
    )
    {

    SOCK_FUNC *	pSockFunc = NULL;

    if (buf == NULL || from == NULL || pFromLen == NULL || iosFdValue (s) ==  ERROR)
        {
        netErrnoSet (EINVAL);
        return (ERROR);
        }

    pSockFunc = pSockFdMap[s];
    if ((pSockFunc == NULL) || (pSockFunc->recvfromRtn == NULL))
	{
        netErrnoSet (ENOTSUP);
	return (ERROR);
	}

    return ((pSockFunc->recvfromRtn) (s, buf, bufLen, flags,
	from, pFromLen));
    }

/*******************************************************************************
*
* recv - receive data from a socket
*
* This routine receives data from a connection-based (stream) socket.
*
* The maximum length of <buf> is subject to the limits on TCP buffer
* size; see the discussion of SO_RCVBUF in the setsockopt() manual
* entry.
*
* 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
*
* RETURNS
* The number of bytes received, or ERROR if the call fails.
*
* SEE ALSO
* setsockopt()
*/

int recv
    (
    FAST int    s,      /* socket to receive data from */
    FAST char   *buf,   /* buffer to write data to */
    FAST int    bufLen, /* length of buffer */
    FAST int    flags   /* flags to underlying protocols */
    )
    {

    SOCK_FUNC *	pSockFunc = NULL;

    if (buf == NULL || iosFdValue (s) ==  ERROR)
        {
        netErrnoSet (EINVAL);
        return (ERROR);
        }

    pSockFunc = pSockFdMap[s];
    if ((pSockFunc == NULL) || (pSockFunc->recvRtn == NULL))
	{
        netErrnoSet (ENOTSUP);
	return (ERROR);
	}

    return ((pSockFunc->recvRtn) (s, buf, bufLen, flags));
    }

/*******************************************************************************
*
* recvmsg - receive a message from a socket
*
* This routine receives a message from a datagram socket.  It may be used in
* place of recvfrom() to decrease the overhead of breaking down the
* message-header structure `msghdr' for each message.
*
* For BSD 4.4 sockets a copy of the <mp>->msg_iov array will be made.  This
* requires a cluster from the network stack system pool of size 
* <mp>->msg_iovlen * sizeof (struct iovec) or 8 bytes. 
*
* RETURNS
* The number of bytes received, or ERROR if the call fails.
*/

int recvmsg
    (
    int                 sd,     /* socket to receive from */
    struct msghdr       *mp,    /* scatter-gather message header */
    int                 flags   /* flags to underlying protocols */
    )
    {

    SOCK_FUNC *	pSockFunc = NULL;

    if (mp == NULL || iosFdValue (sd) ==  ERROR)
         {
        netErrnoSet (EINVAL);
        return (ERROR);
        }

    pSockFunc = pSockFdMap[sd];
    if ((pSockFunc == NULL) || (pSockFunc->recvmsgRtn == NULL))
	{
        netErrnoSet (ENOTSUP);
	return (ERROR);
	}

    return ((pSockFunc->recvmsgRtn) (sd, mp, flags));
    }

/*******************************************************************************
*
* setsockopt - set socket options
*
* This routine sets the options associated with a socket.
* To manipulate options at the "socket" level, <level> should be SOL_SOCKET.
* Any other levels should use the appropriate protocol number.
*
* OPTIONS FOR STREAM SOCKETS
* The following sections discuss the socket options available for
* stream (TCP) sockets.
*
* .SS "SO_KEEPALIVE -- Detecting a Dead Connection"
* Specify the SO_KEEPALIVE option to make the transport protocol (TCP)
* initiate a timer to detect a dead connection:
* .CS
*     setsockopt (sock, SOL_SOCKET, SO_KEEPALIVE, &optval, sizeof (optval));
* .CE
* This prevents an application from  hanging on an invalid connection.
* The value at <optval> for this option is an integer (type `int'),
* either 1 (on) or 0 (off).
*
* The integrity of a connection is verified by transmitting
* zero-length TCP segments triggered by a timer, to force a response
* from a peer node.  If the peer does not respond after repeated
* transmissions of the KEEPALIVE segments, the connection is dropped,
* all protocol data structures are reclaimed, and processes sleeping
* on the connection are awakened with an ETIMEDOUT error.
*
* The ETIMEDOUT timeout can happen in two ways.  If the connection is
* not yet established, the KEEPALIVE timer expires after idling
* for TCPTV_KEEP_INIT.  If the connection is established, the
* KEEPALIVE timer starts up when there is no traffic for
* TCPTV_KEEP_IDLE.  If no response is received from the peer after
* sending the KEEPALIVE segment TCPTV_KEEPCNT times with interval
* TCPTV_KEEPINTVL, TCP assumes that the connection is invalid.
* The TCPTV_KEEP_INIT, TCPTV_KEEP_IDLE, TCPTV_KEEPCNT, and TCPTV_KEEPINTVL 
* parameters are defined in the file target/h/netinet/tcp_timer.h.
*
* .SS "SO_LINGER -- Closing a Connection"
* Specify the SO_LINGER option to determine whether TCP should perform a
* "graceful" close:
* .CS
*     setsockopt (sock, SOL_SOCKET, SO_LINGER, &optval, sizeof (optval));
* .CE
* To achieve a "graceful" close in response to the shutdown of a connection,
* TCP puts itself through an elaborate set of state transitions.  The goal is 
* to assure that all the unacknowledged data in the transmission channel are 
* acknowledged, and that the peer is shut down properly.
*
* The value at <optval> indicates the amount of time to linger if
* there is unacknowledged data, using `struct linger' in
* target/h/sys/socket.h.  The `linger' structure has two members:
* `l_onoff' and `l_linger'.  `l_onoff' can be set to 1 to turn on the
* SO_LINGER option, or set to 0 to turn off the SO_LINGER option.
* `l_linger' indicates the amount of time to linger.  If `l_onoff' is
* turned on and `l_linger' is set to 0, a default value TCP_LINGERTIME
* (specified in netinet/tcp_timer.h) is used for incoming
* connections accepted on the socket.
*
* When SO_LINGER is turned on and the `l_linger' field is set to 0,
* TCP simply drops the connection by sending out an RST (if a
* connection is already established).  This frees up the space for the TCP
* protocol control block, and wakes up all tasks sleeping on the
* socket.
*
* For the client side socket, the value of `l_linger' is not changed
* if it is set to 0.  To make sure that the value of `l_linger' is 0
* on a newly accepted socket connection, issue another setsockopt()
* after the accept() call.
*
* Currently the exact value of `l_linger' time is actually ignored
* (other than checking for 0); that is, TCP performs the state
* transitions if `l_linger' is not 0, but does not explicitly use its
* value.
*
* .SS "TCP_NODELAY -- Delivering Messages Immediately"
* Specify the TCP_NODELAY option for real-time protocols, such as the X
* Window System Protocol, that require immediate delivery of many small
* messages:
* .CS
* setsockopt (sock, IPPROTO_TCP, TCP_NODELAY, &optval, sizeof (optval));
* .CE
* The value at <optval> is an integer (type `int') set to either 1
* (on) or 0 (off).
*
* By default, the VxWorks TCP implementation employs an algorithm that
* attempts to avoid the congestion that can be produced by a large number
* of small TCP segments. This typically arises with virtual terminal
* applications (such as telnet or rlogin) across networks that have
* low bandwidth and long delays.  The algorithm attempts to have no
* more than one outstanding unacknowledged segment in the transmission
* channel while queueing up the rest of the smaller segments for later
* transmission.  Another segment is sent only if enough new data is
* available to make up a maximum sized segment, or if the outstanding
* data is acknowledged.
*
* This congestion-avoidance algorithm works well for virtual terminal
* protocols and bulk data transfer protocols such as FTP without any
* noticeable side effects.  However, real-time protocols that require
* immediate delivery of many small messages, such as the X Window
* System Protocol, need to defeat this facility to guarantee proper
* responsiveness in their operation.
*
* TCP_NODELAY is a mechanism to turn off the use of this algorithm.
* If this option is turned on and there is data to be sent out, TCP
* bypasses the congestion-avoidance algorithm: any available data
* segments are sent out if there is enough space in the send window.
*
* .SS "TCP_MAXSEG -- Changing TCP MSS for the connection"
* Specify the TCP_MAXSEG option to decrease the maximum allowable size of an
* outgoing TCP segment. This option cannot be used to increase the MSS.
* .CS
* setsockopt (sock, IPPROTO_TCP, TCP_MAXSEG, &optval, sizeof (optval));
* .CE
* The value at <optval> is an integer set to the desired MSS (eg. 1024).
*
* When a TCP socket is created, the MSS is initialized to the default MSS
* value which is determined by the configuration parameter `TCP_MSS_DFLT' (512
* by default). When a connection request is received from the other end with
* an MSS option, the MSS is modified depending on the value of the received
* MSS and on the results of Path MTU Discovery (which is enabled by default). 
* The MSS may be set as high as the outgoing interface MTU (1460 for an 
* Ethernet). Therefore, after a call to `socket' but before a connection is 
* established, an application can only decrease the MSS from its default of 512. 
* After a connection is established, the application can decrease the MSS from 
* whatever value was selected.
*
* .SS "SO_DEBUG -- Debugging the  underlying protocol"
* Specify the SO_DEBUG option to let the underlying protocol module record
* debug information.
* .CS
*     setsockopt (sock, SOL_SOCKET, SO_DEBUG, &optval, sizeof (optval));
* .CE
* The value at <optval> for this option is an integer (type `int'),
* either 1 (on) or 0 (off).
*
* OPTION FOR DATAGRAM SOCKETS
* The following section discusses an option for datagram (UDP) sockets.
*
* .SS "SO_BROADCAST -- Sending to Multiple Destinations"
* Specify the SO_BROADCAST option when an application needs to send
* data to more than one destination:
* .CS
*     setsockopt (sock, SOL_SOCKET, SO_BROADCAST, &optval, sizeof (optval));
* .CE
* The value at <optval> is an integer (type <int>), either 1 (on) or 0
* (off).
*
* OPTIONS FOR DATAGRAM AND RAW SOCKETS
* The following section discusses options for multicasting on UDP and RAW
* sockets.
*
* .SS "IP_ADD_MEMBERSHIP -- Join a Multicast Group"
* Specify the IP_ADD_MEMBERSHIP option when a process needs to join
* multicast group:
* .CS
*     setsockopt (sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *)&ipMreq,
*                 sizeof (ipMreq));
* .CE
* The value of <ipMreq> is an 'ip_mreq' structure. 
* `ipMreq.imr_multiaddr.s_addr' is the internet multicast address
* `ipMreq.imr_interface.s_addr' is the internet unicast address of the 
* interface through which the multicast packet needs to pass.
*
* .SS "IP_DROP_MEMBERSHIP -- Leave a Multicast Group"
* Specify the IP_DROP_MEMBERSHIP option when a process needs to leave
* a previously joined multicast group:
* .CS
*     setsockopt (sock, IPPROTO_IP, IP_DROP_MEMBERSHIP, (char *)&ipMreq,
*                 sizeof (ipMreq));
* .CE
* The value of <ipMreq> is an 'ip_mreq' structure.  
* `ipMreq.imr_multiaddr.s_addr' is the internet multicast address.
* `ipMreq.imr_interface.s_addr' is the internet unicast address of the 
* interface to which the multicast address was bound.
*
* .SS "IP_MULTICAST_IF -- Select a Default Interface for Outgoing Multicasts"
* Specify the IP_MULTICAST_IF option when an application needs to specify
* an outgoing network interface through which all multicast packets
* are sent:
* .CS
*     setsockopt (sock, IPPROTO_IP, IP_MULTICAST_IF, (char *)&ifAddr,
*                 sizeof (mCastAddr));
* .CE
* The value of <ifAddr> is an 'in_addr' structure.  
* `ifAddr.s_addr' is the internet network interface address.
*
* .SS "IP_MULTICAST_TTL -- Select a Default TTL"
* Specify the IP_MULTICAST_TTL option when an application needs to select
* a default TTL (time to live) for outgoing multicast
* packets:
*
* .CS
*     setsockopt (sock, IPPROTO_IP, IP_MULTICAST_TTL, &optval, sizeof(optval));
* .CE
* The value at <optval> is an integer (type <int>), time to live value.
*
* .TS
* tab(|);
* lf3 lf3 lf3
* l l l.
* optval(TTL)  |  Application                   | Scope
* _
* 0            |                                | same interface
* 1            |                                | same subnet
* 31           | local event video              | 
* 32           |                                | same site
* 63           | local event audio              | 
* 64           |                                | same region
* 95           | IETF channel 2 video           | 
* 127          | IETF channel 1 video           | 
* 128          |                                | same continent
* 159          | IETF channel 2 audio           | 
* 191          | IETF channel 1 audio           | 
* 223          | IETF channel 2 low-rate audio  | 
* 255          | IETF channel 1 low-rate audio  |
*              | unrestricted in scope          |
* .TE
*
* .SS "IP_MULTICAST_LOOP -- Enable or Disable Loopback"
* Enable or disable loopback of outgoing multicasts.
* .CS
*     setsockopt (sock, IPPROTO_IP, IP_MULTICAST_LOOP, &optval, sizeof(optval));
* .CE
* The value at <optval> is an integer (type <int>), either 1(on) or 0
* (off).
*
* OPTIONS FOR DATAGRAM, STREAM AND RAW SOCKETS