recv(2)

NAME
     recv, recvfrom, recvmsg - receive a message from a socket

SYNOPSIS
     #include <sys/types.h>
     #include <sys/socket.h>

     int recv(int s, void *buf, int len, int flags);
     int recvfrom(int s, void *buf, int len, int flags,
               struct sockaddr *from, int *fromlen);
     int recvmsg(int s, struct msghdr *msg, int flags);

DESCRIPTION
     Recv, recvfrom, and recvmsg are used to receive messages from a socket.

     The recv call is normally used only on a connected socket (see
     connect(2)), while recvfrom and recvmsg may be used to receive data on a
     socket whether it is in a connected state or not.

     If from is non-zero, the source address of the message is filled in.
     Fromlen is a value-result parameter, initialized to the size of the
     buffer associated with from, and modified on return to indicate the
     actual size of the address stored there.  A successful call returns the
     length of the message.  If a message is too long to fit in the supplied
     buffer, excess bytes may be discarded depending on the type of socket the
     message is received from (see socket(2)).

     If no messages are available at the socket, the receive call waits for a
     message to arrive, unless the socket is nonblocking (see ioctl(2)) in
     which case the call returns -1 with the external variable errno set to
     EWOULDBLOCK.

     The select(2) call may be used to determine when more data arrives.

     The flags argument to a recv call is formed by or'ing one or more of the
     values,

       #define MSG_OOB      0x1  /* process out-of-band data */
       #define MSG_PEEK     0x2  /* peek at incoming message */
       #define MSG_WAITALL  0x40 /* wait for full request or error */
       #define MSG_DONTWAIT 0x80 /* this message should be nonblocking */

     The recvmsg call uses a msghdr structure to minimize the number of
     directly supplied parameters.  This structure has the following form, as
     defined in <sys/socket.h>:

          struct msghdr {
               caddr_t   msg_name; /* optional address */
               int  msg_namelen;   /* size of address */
               struct    iovec *msg_iov;     /* scatter/gather array */
               int  msg_iovlen;    /* # elements in msg_iov */
              caddr_t    msg_accrights; /* access rights sent/received */
               int  msg_accrightslen;
          };

     Here msg_name and msg_namelen specify the destination address if the
     socket is unconnected; msg_name may be given as a null pointer if no
     names are desired or required.  The msg_iov and msg_iovlen describe the
     scatter/gather locations.  The iovec structure is defined as

          struct iovec {
               caddr_t   iov_base;
               int  iov_len;
          };

     Each iovec entry specifies the base address and length of an area in
     memory where data should be placed. recvmsg will always fill an area
     completely before proceeding to the next.

     A buffer to receive any access rights sent along with the message is
     specified in msg_accrights, which has length msg_accrightslen.  Access
     rights are opaque data that are interpreted within the context of the
     communication domain and are currently limited to file descriptors, which
     each occupy the size of an int (see unix(7F) for details).

RETURN VALUE
     These calls return the number of bytes received, or -1 if an error
     occurred.

ERRORS
     The calls fail if:

     [EBADF]             The argument s is an invalid descriptor.

     [ENOTSOCK]          The argument s is not a socket.

     [EWOULDBLOCK]       The socket is marked non-blocking and the receive
                         operation would block.

     [EINTR]             The receive was interrupted by delivery of a signal
                         before any data was available for the receive.

     [EFAULT]            The data was specified to be received into a non-
                         existent or protected part of the process address
                         space.

SEE ALSO
     fcntl(2), getsockopt(2), read(2), select(2), send(2), socket(2)

NOTES
     ABI-compliant versions of the above calls can be obtained from
     libsocket.so.

     When using recvmsg to receive access rights, it may be necessary for the
     application to request a single byte of normal data as well, so that the
     call does not return immediately if the access rights are not yet
     present.  Doing so will cause the recvmsg call to block until the access
     rights are available.