recv(2N)                                                 recv(2N)



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

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

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

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

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

          cc ... -lnet

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

          The recv call may be used only on a connected socket (see
          connect(2N)), 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.  The length of the message is returned in cc.  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 cc of -1 is
          returned with the external variable errno set to
          EWOULDBLOCK.

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



     Page 1                                        (last mod. 1/14/87)

     recv(2N)                                                 recv(2N)



          The flags argument to a send call is formed by or'ing 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 msgname and msgnamelen specify the destination
          address if the socket is unconnected; msgname may be given
          as a null pointer if no names are desired or required.  The
          msgiov and msgiovlen describe the scatter gather
          locations.  Access rights to be sent along with the message
          are specified in msgaccrights, which has length
          msgaccrightslen.

     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.

     LINKING
          This library is accessed by specifying -lnet as the last
          argument to the compile line, e.g.:



     Page 2                                        (last mod. 1/14/87)

     recv(2N)                                                 recv(2N)



            cc -o prog prog.c -lnet

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



















































     Page 3                                        (last mod. 1/14/87)