int recv(int s, void *buf, int len, unsigned int flags);
int recvfrom(int s, void *buf, int len, unsigned int flags
struct sockaddr *from, int *fromlen);
int recvfrom_secure(int s, void *buf, int len, unsigned int flags
struct sockaddr *from, int *fromlen, security_id_t *sso_sid, security_id_t * msg_sid);
int recvmsg(int s, struct msghdr *msg, unsigned int flags);
int recvmsg_secure(int s, struct msghdr *msg, unsigned int flags, security_id_t *sso_sid, security_id_t *msg_sid);
If from is not NULL, and the socket is not connection-oriented, 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 recvfrom_secure and recvmsg_secure calls may be used to obtain the SID of the source socket using the sso_sid result parameter and the SID of the message using the msg_sid result parameter.
The recv call is normally used only on a connected socket (see connect(2)) and is identical to recvfrom with a NULL from parameter. As it is redundant, it may not be supported in future releases.
All three routines return the length of the message on successful completion. 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 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 set 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) or poll(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 following values:
#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
{
__u32 ee_errno; /* error number */
__u8 ee_origin; /* where the error originated */
__u8 ee_type; /* type */
__u8 ee_code; /* code */
__u8 ee_pad;
__u32 ee_info; /* additional information */
__u32 ee_data; /* other data */
};
struct sockaddr *SOCK_EE_OFFENDER(struct sock_extended_err *);
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 {
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 msg_iov */
void * msg_control; /* ancillary data, see below */
socklen_t msg_controllen; /* ancillary data buffer len */
int msg_flags; /* flags on received message */
};
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. Msg_iov and msg_iovlen describe scatter-gather locations, as discussed in readv(2). 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 msg_control; after the successful call return it will contain 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 cmsg(3).
As an example, Linux uses this auxiliary data mechanism to pass extended errors, IP options or file descriptors over Unix sockets.
The msg_flags field is set on return according to the message received. MSG_EOR indicates end-of-record; the data returned completed a record (generally used with sockets of type SOCK_SEQPACKET). MSG_TRUNC indicates that the trailing portion of a datagram was discarded because the datagram was larger than the buffer supplied. MSG_CTRUNC indicates that some control data were discarded due to lack of space in the buffer for ancillary data. MSG_OOB is returned to indicate that expedited or out-of-band data were received. MSG_ERRQUEUE indicates that no data was received but an extended error from the socket error queue.