recv(2N)                                                 recv(2N)



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

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

     int recv(s, buf, len, flags)
     int s;
     char *buf;
     int len, flags;

     int recvfrom(s, buf, len, flags, from, fromlen)
     int s;
     char *buf;
     int len, flags;
     struct sockaddr *from;
     int *fromlen;

     int recvmsg(s, msg, flags)
     int s;
     struct msghdr msg[];
     int flags;

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

     The recv call may be used only on a connected socket (that
     is, when connect(2N) has been used), 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 nonzero, 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.  The length of the message is returned.  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(2N)).

     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 a -1 is returned
     with the external variable errno set
     to EWOULDBLOCK.

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





January 1992                                                    1

recv(2N)                                                 recv(2N)



     The flags argument to a send call is formed by ORing one or
     more of the values:

        #define MSG_PEEK 0x1  /* peek at incoming message */
        #define MSG_OOB  0x2  /* process out-of-band data */


     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   iov *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.  Access rights to be sent along with the message
     are specified in msg_accrights, which has length
     msg_accrightslen.

STATUS MESSAGES AND VALUES
     These calls return the number of bytes received, or -1 if an
     error occurred.

     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 nonblocking 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
          nonexistent or protected part of the process address



2                                                    January 1992

recv(2N)                                                 recv(2N)



          space.

SEE ALSO
     connect(2N), read(2), send(2N), socket(2N)



















































January 1992                                                    3