Seth Woolley's Man Viewer

recv(2) - recv, recvfrom, recvmsg, recv, recvfrom, recvmsg - receive a message from a socket - man 2 recv

([section] manual, -k keyword, -K [section] search, -f whatis)
man plain no title

RECV(2)                    Linux Programmer's Manual                   RECV(2)

       recv, recvfrom, recvmsg - receive a message from a socket(2,7,n)

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

       ssize_t recv(int s, void *buf, size_t len, int flags);

       ssize_t  recvfrom(int s, void *buf, size_t len, int flags, struct sock-
       addr *from, socklen_t *fromlen);

       ssize_t recvmsg(int s, struct msghdr *msg, int flags);

       The recvfrom and recvmsg calls are used  to  receive  messages  from  a
       socket(2,7,n),  and  may be used to receive data on a socket(2,7,n) whether or not it
       is connection-oriented.

       If from is not NULL, and the underlying protocol  provides  the  source
       address,  this  source address is filled in.  The argument fromlen is a
       value-result parameter, initialized to the size of the  buffer  associ-
       ated  with  from, and modified on return to indicate the actual size of
       the address stored there.

       The recv call is normally used only on a  connected  socket(2,7,n)  (see  con-
       nect(2)) and is identical to recvfrom with a NULL from parameter.

       All  three routines return the length of the message on successful com-
       pletion.  If a message is too long  to  fit  in(1,8)  the  supplied  buffer,
       excess  bytes may be discarded depending on the type of socket(2,7,n) the mes-
       sage is received from (see socket(2,7,n)(2)).

       If no messages are available at the socket(2,7,n), the receive calls wait  for
       a message to arrive, unless the socket(2,7,n) is nonblocking (see fcntl(2)) in(1,8)
       which case the value -1 is returned and the external variable errno set(7,n,1 builtins)
       to EAGAIN.  The receive calls normally return any data available, up to
       the requested amount, rather than  waiting  for  receipt  of  the  full
       amount requested.

       The  select(2,7,2 select_tut)(2)  or poll(2) call may be used to determine when more data

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

              This flag requests receipt of out-of-band data that would not be
              received in(1,8) the normal data stream.  Some protocols place  expe-
              dited  data  at the head of the normal data queue(1,3), and thus this
              flag cannot be used with such protocols.

              This flag causes the receive operation to return data  from  the
              beginning  of  the receive queue(1,3) without removing that data from
              the queue.  Thus, a subsequent receive call will return the same

              This  flag  requests  that  the  operation  block until the full
              request is satisfied.  However, the call may still  return  less(1,3)
              data  than  requested if(3,n) a signal(2,7) is caught, an error(8,n) or discon-
              nect occurs, or the next data to be received is of  a  different
              type than that returned.

              Return  the  real  length of the packet, even when it was longer
              than the passed buffer. Only valid for packet sockets.

              This flag specifies that queued errors should be  received  from
              the  socket(2,7,n)  error(8,n)  queue.   The error(8,n) is passed in(1,8) an ancillary
              message  with  a  type  dependent  on  the  protocol  (for  IPv4
              IP_RECVERR).   The  user  should  supply  a buffer of sufficient
              size. See cmsg(3) and ip(7,8)(7) for more information.   The  payload
              of the original packet that caused the error(8,n) is passed as normal
              data via msg_iovec.  The original  destination  address  of  the
              datagram that caused the error(8,n) is supplied via msg_name.

              For local errors, no address is passed (this can be checked with
              the cmsg_len member of the cmsghdr).  For  error(8,n)  receives,  the
              MSG_ERRQUEUE  is  set(7,n,1 builtins)  in(1,8)  the  msghdr.  After an error(8,n) has been
              passed, the pending socket(2,7,n) error(8,n) is  regenerated  based  on  the
              next  queued  error(8,n) and will be passed on the next socket(2,7,n) opera-

              The error(8,n) is supplied in(1,8) a sock_extended_err structure:

              #define SO_EE_ORIGIN_NONE       0
              #define SO_EE_ORIGIN_LOCAL      1
              #define SO_EE_ORIGIN_ICMP       2
              #define SO_EE_ORIGIN_ICMP6      3

              struct sock_extended_err
                  u_int32_t       ee_errno;   /* error(8,n) number */
                  u_int8_t        ee_origin;  /* where the error(8,n) originated */
                  u_int8_t        ee_type;    /* type */
                  u_int8_t        ee_code;    /* code */
                  u_int8_t        ee_pad;
                  u_int32_t       ee_info;    /* additional information */
                  u_int32_t       ee_data;    /* other data */
                  /* More data may follow */

              struct sockaddr *SO_EE_OFFENDER(struct sock_extended_err *);

              ee_errno contains the errno number of the queued error.  ee_ori-
              gin is the origin code of where the error(8,n) originated.  The other
              fields are protocol specific. The macro SOCK_EE_OFFENDER returns
              a  pointer  to the address of the network object where the error(8,n)
              originated from given a pointer to the  ancillary  message.   If
              this  address is not known, the sa_family member of the sockaddr
              contains AF_UNSPEC and the other  fields  of  the  sockaddr  are
              undefined.  The  payload  of the packet that caused the error(8,n) is
              passed as normal data.

              For local errors, no address is passed (this can be checked with
              the  cmsg_len  member  of the cmsghdr).  For error(8,n) receives, the
              MSG_ERRQUEUE is set(7,n,1 builtins) in(1,8) the msghdr.   After  an  error(8,n)  has  been
              passed,  the  pending  socket(2,7,n)  error(8,n) is regenerated based on the
              next queued error(8,n) and will be passed on the next  socket(2,7,n)  opera-

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

              struct msghdr {
                  void         * msg_name;     /* optional address */
                  socklen_t    msg_namelen;    /* size of address */
                  struct iovec * msg_iov;      /* scatter/gather array */
                  size_t       msg_iovlen;     /* # elements in(1,8) msg_iov */
                  void         * msg_control;  /* ancillary data, see below */
                  socklen_t    msg_controllen; /* ancillary data buffer len */
                  int          msg_flags;      /* flags on received message */

       Here  msg_name and msg_namelen specify the source address if(3,n) the socket(2,7,n)
       is unconnected; msg_name may be given as a null pointer if(3,n) no names are
       desired  or required.  The fields msg_iov and msg_iovlen describe scat-
       ter-gather locations, as discussed in(1,8) readv(2).  The field msg_control,
       which  has length msg_controllen, points to a buffer for other protocol
       control related messages or miscellaneous ancillary data. When  recvmsg
       is  called,  msg_controllen  should contain the length of the available
       buffer in(1,8) msg_control; upon return from a successful call it will  con-
       tain the length of the control message sequence.

       The messages are of the form:

              struct cmsghdr {
                  socklen_t   cmsg_len;   /* data byte count, including hdr */
                  int         cmsg_level; /* originating protocol */
                  int         cmsg_type;  /* protocol-specific type */
              /* followed by
                  u_char      cmsg_data[]; */

       Ancillary  data  should  only  be  accessed  by  the  macros defined in(1,8)

       As an example,  Linux  uses  this  auxiliary  data  mechanism  to  pass
       extended errors, IP options or file(1,n) descriptors over Unix sockets.

       The  msg_flags  field  in(1,8) the msghdr is set(7,n,1 builtins) on return of recvmsg().  It
       can contain several flags:

              indicates end-of-record; the data returned  completed  a  record
              (generally used with sockets of type SOCK_SEQPACKET).

              indicates  that the trailing portion of a datagram was discarded
              because the datagram was larger than the buffer supplied.

              indicates that some control data were discarded due to  lack  of
              space in(1,8) the buffer for ancillary data.

              is  returned to indicate that expedited or out-of-band data were

              indicates that no data was received but an extended  error(8,n)  from
              the socket(2,7,n) error(8,n) queue.

              Enables  non-blocking  operation;  if(3,n) the operation would block,
              EAGAIN is returned (this can also be enabled  using  the  O_NON-
              BLOCK with the F_SETFL fcntl(2)).

       These  calls  return  the  number  of bytes received, or -1 if(3,n) an error(8,n)
       occurred. The return value will be 0 when the  peer  has  performed  an
       orderly shutdown.

       These  are  some  standard  errors generated by the socket(2,7,n) layer. Addi-
       tional errors may be generated and returned from the underlying  proto-
       col modules; see their manual pages.

       EAGAIN The  socket(2,7,n)  is  marked  non-blocking  and the receive operation
              would block, or a receive timeout(1,3x,3x cbreak) had been set(7,n,1 builtins) and  the  timeout(1,3x,3x cbreak)
              expired before data was received.

       EBADF  The argument s is an invalid descriptor.

              A remote host(1,5) refused to allow the network connection (typically
              because it is not running the requested service).

       EFAULT The  receive  buffer  pointer(s)  point  outside  the  process's
              address space.

       EINTR  The  receive  was interrupted by delivery of a signal(2,7) before any
              data were available.

       EINVAL Invalid argument passed.

       ENOMEM Could not allocate memory for recvmsg.

              The socket(2,7,n) is associated with a connection-oriented protocol and
              has not been connected (see connect(2) and accept(2,8)(2)).

              The argument s does not refer to a socket.

       4.4BSD   (these   function  calls  first  appeared  in(1,8)  4.2BSD),  POSIX

       POSIX only describes the MSG_OOB, MSG_PEEK, and MSG_WAITALL flags.

       The prototypes given above follow glibc2.  The Single  Unix  Specifica-
       tion  agrees, except that it has return values of type `ssize_t' (while
       BSD 4.* and libc4 and libc5 all have `int').   The  flags  argument  is
       `int' in(1,8) BSD 4.*, but `unsigned int' in(1,8) libc4 and libc5.  The len argu-
       ment is `int' in(1,8) BSD 4.*, but `size_t' in(1,8) libc4 and libc5.  The fromlen
       argument  is  `int  *'  in(1,8)  BSD  4.*,  libc4  and  libc5.   The present
       `socklen_t *' was invented by POSIX.  See also accept(2,8)(2).

       fcntl(2), getsockopt(2), read(2,n,1 builtins)(2), select(2,7,2 select_tut)(2), socket(2,7,n)(2), cmsg(3)

Linux Man Page                    2002-12-31                           RECV(2)

References for this manual (incoming links)