NAME
recv, recvfrom, recvmsg - receive a message from a socket SYNOPSIS
#include
#include
ssizet recv(int sockfd, void *buf, sizet len, int flags); ssizet recvfrom(int sockfd, void *buf, sizet len, int flags, struct sockaddr *srcaddr, socklent *addrlen); ssizet recvmsg(int sockfd, struct msghdr *msg, int flags); DESCRIPTION The recvfrom() and recvmsg() calls are used to receive messages from a socket, and may be used to receive data on a socket whether or not it is connection-oriented. If srcaddr is not NULL, and the underlying protocol provides the source address, this source address is filled in. When srcaddr is NULL, nothing is filled in; in this case, addrlen is not used, and
should also be NULL. The argument addrlen is a value-result argument, which the caller should initialize before the call to the size of the buffer associated with srcaddr, and modified on return to indicate the actual size of the source address. The returned address is truncated if the buffer provided is too small; in this case, addrlen will return a value greater than was supplied to the call. The recv() call is normally used only on a connected socket (see con‐ nect(2)) and is identical to recvfrom() with a NULL srcaddr argument. All three routines return the length of the message on successful com‐ pletion. If a message is too long to fit in the supplied buffer, excess bytes may be discarded depending on the type of socket the mes‐ sage is received from. If no messages are available at the socket, the receive calls wait for a message to arrive, unless the socket is nonblocking (see fcntl(2)),
in which case the value -1 is returned and the external variable errno is set to EAGAIN or EWOULDBLOCK. 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) or poll(2) call may be used to determine when more data arrives. The flags argument is formed by ORing one or more of the following val‐ ues: MSGCMSGCLOEXEC (recvmsg() only; since Linux 2.6.23)
Set the close-on-exec flag for the file descriptor received via a UNIX domain file descriptor using the SCMRIGHTS operation (described in unix(7)). This flag is useful for the same rea‐ sons as the OCLOEXEC flag of open(2). MSGDONTWAIT (since Linux 2.2) Enables nonblocking operation; if the operation would block, the call fails with the error EAGAIN or EWOULDBLOCK (this can also be enabled using the ONONBLOCK flag with the FSETFL fcntl(2)). MSGERRQUEUE (since Linux 2.2) This flag specifies that queued errors should be received from the socket error queue. The error is passed in an ancillary message with a type dependent on the protocol (for IPv4 IPRECVERR). The user should supply a buffer of sufficient size. See cmsg(3) and ip(7) for more information. The payload of the original packet that caused the error is passed as normal data via msgiovec. The original destination address of the datagram that caused the error is supplied via msgname. For local errors, no address is passed (this can be checked with the cmsglen member of the cmsghdr). For error receives, the MSGERRQUEUE is set in the msghdr. After an error has been passed, the pending socket error is regenerated based on the next queued error and will be passed on the next socket opera‐ tion. The error is supplied in a sockextendederr structure:
#define SOEEORIGINNONE 0
#define SOEEORIGINLOCAL 1
#define SOEEORIGINICMP 2
#define SOEEORIGINICMP6 3 struct sockextendederr { uint32t eeerrno; /* error number */ uint8t eeorigin; /* where the error originated */ uint8t eetype; /* type */ uint8t eecode; /* code */ uint8t eepad; /* padding */ uint32t eeinfo; /* additional information */ uint32t eedata; /* other data */ /* More data may follow */ }; struct sockaddr *SOEEOFFENDER(struct sockextendederr *); eeerrno contains the errno number of the queued error. eeori‐ gin is the origin code of where the error originated. The other
fields are protocol-specific. The macro SOCKEEOFFENDER returns a pointer to the address of the network object where the error originated from given a pointer to the ancillary message. If this address is not known, the safamily member of the sock‐ addr contains AFUNSPEC and the other fields of the sockaddr are undefined. The payload of the packet that caused the error is passed as normal data. For local errors, no address is passed (this can be checked with the cmsglen member of the cmsghdr). For error receives, the MSGERRQUEUE is set in the msghdr. After an error has been passed, the pending socket error is regenerated based on the next queued error and will be passed on the next socket opera‐ tion. MSGOOB
This flag requests receipt of out-of-band data that would not be received in the normal data stream. Some protocols place expe‐ dited data at the head of the normal data queue, and thus this flag cannot be used with such protocols. MSGPEEK This flag causes the receive operation to return data from the beginning of the receive queue without removing that data from the queue. Thus, a subsequent receive call will return the same data. MSGTRUNC (since Linux 2.2) For raw (AFPACKET), Internet datagram (since Linux 2.4.27/2.6.8), netlink (since Linux 2.6.22) and UNIX datagram (since Linux 3.4) sockets: return the real length of the packet or datagram, even when it was longer than the passed buffer. Not implemented for UNIX domain (unix(7)) sockets. For use with Internet stream sockets, see tcp(7). MSGWAITALL (since Linux 2.2) This flag requests that the operation block until the full request is satisfied. However, the call may still return less data than requested if a signal is caught, an error or discon‐ nect occurs, or the next data to be received is of a different type than that returned. The recvmsg() call uses a msghdr structure to minimize the number of directly supplied arguments. This structure is defined as follows in
: struct iovec { /* Scatter/gather array items */ void *iovbase; /* Starting address */ sizet iovlen; /* Number of bytes to transfer */ }; struct msghdr { void *msgname; /* optional address */ socklent msgnamelen; /* size of address */ struct iovec *msgiov; /* scatter/gather array */ sizet msgiovlen; /* # elements in msgiov */ void *msgcontrol; /* ancillary data, see below */ sizet msgcontrollen; /* ancillary data buffer len */ int msgflags; /* flags on received message */ }; Here msgname and msgnamelen specify the source address if the socket is unconnected; msgname may be given as a NULL pointer if no names are desired or required. The fields msgiov and msgiovlen describe scat‐
ter-gather locations, as discussed in readv(2). The field msgcontrol, which has length msgcontrollen, points to a buffer for other protocol
control-related messages or miscellaneous ancillary data. When recvmsg() is called, msgcontrollen should contain the length of the available buffer in msgcontrol; upon return from a successful call it will contain the length of the control message sequence. The messages are of the form: struct cmsghdr { sizet cmsglen; /* Data byte count, including header (type is socklent in POSIX) */ int cmsglevel; /* Originating protocol */
int cmsgtype; /* Protocol-specific type */ /* followed by unsigned char cmsgdata[]; */ }; Ancillary data should be accessed only by the macros defined in cmsg(3). As an example, Linux uses this ancillary data mechanism to pass extended errors, IP options, or file descriptors over UNIX domain sock‐ ets. The msgflags field in the msghdr is set on return of recvmsg(). It can contain several flags: MSGEOR
indicates end-of-record; the data returned completed a record (generally used with sockets of type SOCKSEQPACKET). MSGTRUNC indicates that the trailing portion of a datagram was discarded because the datagram was larger than the buffer supplied. MSGCTRUNC indicates that some control data were discarded due to lack of space in the buffer for ancillary data. MSGOOB
is returned to indicate that expedited or out-of-band data were received. MSGERRQUEUE indicates that no data was received but an extended error from the socket error queue. RETURN VALUE
These calls return the number of bytes received, or -1 if an error occurred. In the event of an error, errno is set to indicate the error. The return value will be 0 when the peer has performed an orderly shutdown. ERRORS These are some standard errors generated by the socket layer. Addi‐ tional errors may be generated and returned from the underlying proto‐ col modules; see their manual pages. EAGAIN or EWOULDBLOCK The socket is marked nonblocking and the receive operation would block, or a receive timeout had been set and the timeout expired
before data was received. POSIX.1-2001 allows either error to be returned for this case, and does not require these constants to have the same value, so a portable application should check for both possibilities. EBADF The argument sockfd is an invalid descriptor. ECONNREFUSED A remote host 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 before any data were available; see signal(7). EINVAL Invalid argument passed. ENOMEM Could not allocate memory for recvmsg(). ENOTCONN
The socket is associated with a connection-oriented protocol and has not been connected (see connect(2) and accept(2)). ENOTSOCK The argument sockfd does not refer to a socket. CONFORMING TO
4.4BSD (these function calls first appeared in 4.2BSD), POSIX.1-2001.
POSIX.1-2001 describes only the MSGOOB, MSGPEEK, and MSGWAITALL flags. NOTES The prototypes given above follow glibc2. The Single UNIX Specifica‐ tion agrees, except that it has return values of type ssizet (while 4.x BSD and libc4 and libc5 all have int). The flags argument is int in 4.x BSD, but unsigned int in libc4 and libc5. The len argument is int in 4.x BSD, but sizet in libc4 and libc5. The addrlen argument is int * in 4.x BSD, libc4 and libc5. The present socklent * was invented by POSIX. See also accept(2).
According to POSIX.1-2001, the msgcontrollen field of the msghdr structure should be typed as socklent, but glibc currently types it as sizet.
See recvmmsg(2) for information about a Linux-specific system call that can be used to receive multiple datagrams in a single call. EXAMPLE An example of the use of recvfrom() is shown in getaddrinfo(3). SEE ALSO fcntl(2), getsockopt(2), read(2), recvmmsg(2), select(2), shutdown(2), socket(2), cmsg(3), sockatmark(3), socket(7) COLOPHON
This page is part of release 3.53 of the Linux man-pages project. A description of the project, and information about reporting bugs, can
be found at http://www.kernel.org/doc/man-pages/.
Linux 2013-04-19 RECV(2)