kernel_recvmsg(9) [centos man page]

KERNEL_RECVMSG(9)						 Linux Networking						 KERNEL_RECVMSG(9)

NAME

       kernel_recvmsg - Receive a message from a socket (kernel space)

SYNOPSIS

       int kernel_recvmsg(struct socket * sock, struct msghdr * msg, struct kvec * vec, size_t num, size_t size, int flags);

ARGUMENTS

       sock
	   The socket to receive the message from

       msg
	   Received message

       vec
	   Input s/g array for message data

       num
	   Size of input s/g array

       size
	   Number of bytes to read

       flags
	   Message flags (MSG_DONTWAIT, etc...)

DESCRIPTION

       On return the msg structure contains the scatter/gather array passed in the vec argument. The array is modified so that it consists of the
       unfilled portion of the original array.

       The returned value is the total number of bytes received, or an error.

COPYRIGHT

Kernel Hackers Manual 3.10					     June 2014							 KERNEL_RECVMSG(9)

recv(2) 							System Calls Manual							   recv(2)

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

Syntax
       #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;

Description
       The and system calls are used to receive messages from a socket.

       The call can be used only on a connected socket. The and calls can be used to receive data on a socket, whether or not it is in a connected
       state.  For further information, see

       If from is nonzero, the source address of the message is filled in.  The 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 If a message is too long to fit in the supplied buffer, excess bytes can be discarded, depending on the type of  socket  the
       message is received from.  For further information, see

       If  no  messages  are  available  at  the socket, the receive call waits for a message to arrive, unless the socket is nonblocking.  If the
       socket is nonblocking, a of -1 is returned, and the external variable errno is set to EWOULDBLOCK.  For further information, see

       The call can be used to determine when more data arrives.

       The flags argument to a send call is formed by ORing one or more of the values following values:
       #define	 MSG_OOB   0x1	/* process out-of-band data */
       #define	 MSG_PEEK  0x2	/* peek at incoming message */
       The 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 can be given as a null pointer if no
       names are desired or required.  The msg_iov and msg_iovlen describe the scatter gather locations, as described in Access rights to be  sent
       along with the message are specified in msg_accrights , which has length msg_accrightslen .

Return Values
       These calls return the number of bytes received, or -1 if an error occurred.

Diagnostics
       The call fails under the following conditions:

       [EBADF]	      The argument s is an invalid descriptor.

       [EINVAL]       The argument length of the message is less than 0.

       [EMSGSIZE]     The message sent on the socket was larger than the internal message buffer.

       [ENOTCONN]     A call was made to from an unconnected stream socket.

       [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 space. The argument
		      fromlen points outside the process address space.

See Also
       read(2), send(2), socket(2)

																	   recv(2)