RETURN VALUE

       On success, the number of bytes read is returned (zero indicates end of file), and the file position is advanced by this number.  It is not an error if this number is smaller than the number of bytes requested; this may happen for example because fewer  bytes  are  actually available  right  now (maybe because we were close to end-of-file, or because we are reading from a pipe, or from a terminal), or because read() was interrupted by a signal.  On error, -1 is returned, and errno is set appropriately.  In this case it is left unspecified whether the file position (if any) changes.

 

1. static int unix_stream_recvmsg(struct kiocb *iocb, struct socket *sock,
2. struct msghdr *msg, size_t size,
3. int flags)
4. {
5. struct sock_iocb *siocb = kiocb_to_siocb(iocb);
6. struct scm_cookie tmp_scm;
7. struct sock *sk = sock->sk;
8. struct unix_sock *u = unix_sk(sk);
9. struct sockaddr_un *sunaddr = msg->msg_name;
10. int copied = 0;
11. int check_creds = 0;
12. int target;
13. int err = 0;
14. long timeo;
15. err = -EINVAL;
16. if (sk->sk_state != TCP_ESTABLISHED)
17. goto out;
18. err = -EOPNOTSUPP;
19. if (flags&MSG_OOB)
20. goto out;
21. target = sock_rcvlowat(sk, flags&MSG_WAITALL, size);
22. timeo = sock_rcvtimeo(sk, flags&MSG_DONTWAIT);
23. msg->msg_namelen = 0;
24. /* Lock the socket to prevent queue disordering
25. * while sleeps in memcpy_tomsg
26. */
27. if (!siocb->scm) {
28. siocb->scm = &tmp_scm;
29. memset(&tmp_scm, 0, sizeof(tmp_scm));
30. }
31. mutex_lock(&u->readlock);
32. do {
33. int chunk;
34. struct sk_buff *skb;
35. unix_state_lock(sk);
36. skb = skb_dequeue(&sk->sk_receive_queue);
37. if (skb == NULL) {
38. if (copied >= target)
39. goto unlock;
40. /*
41. *    POSIX 1003.1g mandates this order.
42. */
43. err = sock_error(sk);
44. if (err)
45. goto unlock;
46. if (sk->sk_shutdown & RCV_SHUTDOWN)
47. goto unlock;
48. unix_state_unlock(sk);
49. err = -EAGAIN;
50. if (!timeo)
51. break;
52. mutex_unlock(&u->readlock);
53. timeo = unix_stream_data_wait(sk, timeo);
54. if (signal_pending(current)) {
55. err = sock_intr_errno(timeo);
56. goto out;
57. }
58. mutex_lock(&u->readlock);
59. continue;
60. unlock:
61. unix_state_unlock(sk);
62. break;
63. }
64. unix_state_unlock(sk);
65. if (check_creds) {
66. /* Never glue messages from different writers */
67. if ((UNIXCB(skb).pid != siocb->scm->pid) ||
68. (UNIXCB(skb).cred != siocb->scm->cred)) {
69. skb_queue_head(&sk->sk_receive_queue, skb);
70. break;
71. }
72. } else {
73. /* Copy credentials */
74. scm_set_cred(siocb->scm, UNIXCB(skb).pid, UNIXCB(skb).cred);
75. check_creds = 1;
76. }
77. /* Copy address just once */
78. if (sunaddr) {
79. unix_copy_addr(msg, skb->sk);
80. sunaddr = NULL;
81. }
82. chunk = min_t(unsigned int, skb->len, size);
83. if (memcpy_toiovec(msg->msg_iov, skb->data, chunk)) {
84. skb_queue_head(&sk->sk_receive_queue, skb);
85. if (copied == 0)
86. copied = -EFAULT;
87. break;
88. }
89. copied += chunk;
90. size -= chunk;
91. /* Mark read part of skb as used */
92. if (!(flags & MSG_PEEK)) {
93. skb_pull(skb, chunk);
94. if (UNIXCB(skb).fp)
95. unix_detach_fds(siocb->scm, skb);
96. /* put the skb back if we didn't use it up.. */
97. if (skb->len) {
98. skb_queue_head(&sk->sk_receive_queue, skb);
99. break;
100. }
101. consume_skb(skb);
102. if (siocb->scm->fp)
103. break;
104. } else {
105. /* It is questionable, see note in unix_dgram_recvmsg.
106. */
107. if (UNIXCB(skb).fp)
108. siocb->scm->fp = scm_fp_dup(UNIXCB(skb).fp);
109. /* put message back and return */
110. skb_queue_head(&sk->sk_receive_queue, skb);
111. break;
112. }
113. } while (size);
114. mutex_unlock(&u->readlock);
115. scm_recv(sock, msg, siocb->scm, flags);
116. out:
117. return copied ? : err;
118. }

1. return copied ? : err;

1. err = sock_error(sk);
2. if (err)
3. goto unlock;
4. if (sk->sk_shutdown & RCV_SHUTDOWN)
5. goto unlock;

1. timeo = unix_stream_data_wait(sk, timeo);
2. if (signal_pending(current)) {
3. err = sock_intr_errno(timeo);
4. goto out;
5. }