Method recv

pkg/sentry/socket/plugin/stack/socket.go:576–614

recv is a helper function for doing non-blocking read once. It returns: 1. number of bytes received; 2. sender address for non-stream socket; 3. control message; 4. message flag; 5. internal error if any

(t *kernel.Task, dst usermem.IOSequence, sysflags int, addr []byte, control []byte)

// 4. message flag;
// 5. internal error if any
func (s *socketOperations) recv(t *kernel.Task, dst usermem.IOSequence, sysflags int, addr []byte, control []byte) (int64, []byte, []byte, int, error) {
	bytes := dst.NumBytes()
	// Directly return if dst is empty.
	if bytes == 0 {
		return 0, addr, control, 0, nil
	}

	// Slow path for non-stream socket(e.g., UDP, raw socket).
	if s.skType != linux.SOCK_STREAM {
		if len(addr) == 0 && s.skType == linux.SOCK_DGRAM {
			addr = make([]byte, sizeofSockaddr)
		}

		tmpBuf := make([]byte, bytes)
		tmpBS := safemem.BlockSeqOf(safemem.BlockFromSafeSlice(tmpBuf))
		iovs := iovecsFromBlockSeq(tmpBS, nil)
		rc, la, lc, flag := cgo.Recvmsg(s.fd, iovs, addr, control, sysflags)
		if rc < 0 {
			_, err := translateReturn(rc)
			return 0, addr /* return the original slice */, control /* return the original slice */, 0, err
		}

		n, err := dst.CopyOut(t, tmpBuf[:rc])
		return int64(n), addr[:la], control[:lc], flag, err
	}

	// Fast path for stream socket(e.g., TCP socket).
	rw := getReadWriter(s.fd)
	rw.to = control
	rw.flags = uint32(sysflags)

	n, err := dst.CopyOutFrom(t, rw)

	control = rw.to
	msgFlags := int(rw.flags)
	putReadWriter(rw)

	return n, nil /* ignore for TCP */, control, msgFlags, err
}

// RecvMsg implements socket.Socket.RecvMsg.
func (s *socketOperations) RecvMsg(t *kernel.Task, dst usermem.IOSequence, flags int, haveDeadline bool, deadline ktime.Time, senderRequested bool, controlDataLen uint64) (int, int, linux.SockAddr, uint32, socket.ControlMessages, *syserr.Error) {