1 /* RxRPC recvmsg() implementation
3 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
12 #include <linux/net.h>
13 #include <linux/skbuff.h>
15 #include <net/af_rxrpc.h>
16 #include "ar-internal.h"
19 * removal a call's user ID from the socket tree to make the user ID available
20 * again and so that it won't be seen again in association with that call
22 void rxrpc_remove_user_ID(struct rxrpc_sock *rx, struct rxrpc_call *call)
24 _debug("RELEASE CALL %d", call->debug_id);
26 if (test_bit(RXRPC_CALL_HAS_USERID, &call->flags)) {
27 write_lock_bh(&rx->call_lock);
28 rb_erase(&call->sock_node, &call->socket->calls);
29 clear_bit(RXRPC_CALL_HAS_USERID, &call->flags);
30 write_unlock_bh(&rx->call_lock);
33 read_lock_bh(&call->state_lock);
34 if (!test_bit(RXRPC_CALL_RELEASED, &call->flags) &&
35 !test_and_set_bit(RXRPC_CALL_RELEASE, &call->events))
36 rxrpc_queue_call(call);
37 read_unlock_bh(&call->state_lock);
41 * receive a message from an RxRPC socket
42 * - we need to be careful about two or more threads calling recvmsg
45 int rxrpc_recvmsg(struct kiocb *iocb, struct socket *sock,
46 struct msghdr *msg, size_t len, int flags)
48 struct rxrpc_skb_priv *sp;
49 struct rxrpc_call *call = NULL, *continue_call = NULL;
50 struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
53 int copy, ret, ullen, offset, copied = 0;
58 _enter(",,,%zu,%d", len, flags);
60 if (flags & (MSG_OOB | MSG_TRUNC))
63 ullen = msg->msg_flags & MSG_CMSG_COMPAT ? 4 : sizeof(unsigned long);
65 timeo = sock_rcvtimeo(&rx->sk, flags & MSG_DONTWAIT);
66 msg->msg_flags |= MSG_MORE;
71 /* return immediately if a client socket has no outstanding
73 if (RB_EMPTY_ROOT(&rx->calls)) {
76 if (rx->sk.sk_state != RXRPC_SERVER_LISTENING) {
77 release_sock(&rx->sk);
79 rxrpc_put_call(continue_call);
84 /* get the next message on the Rx queue */
85 skb = skb_peek(&rx->sk.sk_receive_queue);
87 /* nothing remains on the queue */
89 (msg->msg_flags & MSG_PEEK || timeo == 0))
92 /* wait for a message to turn up */
93 release_sock(&rx->sk);
94 prepare_to_wait_exclusive(rx->sk.sk_sleep, &wait,
96 ret = sock_error(&rx->sk);
100 if (skb_queue_empty(&rx->sk.sk_receive_queue)) {
101 if (signal_pending(current))
102 goto wait_interrupted;
103 timeo = schedule_timeout(timeo);
105 finish_wait(rx->sk.sk_sleep, &wait);
113 ASSERT(call != NULL);
115 _debug("next pkt %s", rxrpc_pkts[sp->hdr.type]);
117 /* make sure we wait for the state to be updated in this call */
118 spin_lock_bh(&call->lock);
119 spin_unlock_bh(&call->lock);
121 if (test_bit(RXRPC_CALL_RELEASED, &call->flags)) {
122 _debug("packet from released call");
123 if (skb_dequeue(&rx->sk.sk_receive_queue) != skb)
129 /* determine whether to continue last data receive */
131 _debug("maybe cont");
132 if (call != continue_call ||
133 skb->mark != RXRPC_SKB_MARK_DATA) {
134 release_sock(&rx->sk);
135 rxrpc_put_call(continue_call);
136 _leave(" = %d [noncont]", copied);
141 rxrpc_get_call(call);
143 /* copy the peer address and timestamp */
144 if (!continue_call) {
145 if (msg->msg_name && msg->msg_namelen > 0)
146 memcpy(msg->msg_name,
147 &call->conn->trans->peer->srx,
148 sizeof(call->conn->trans->peer->srx));
149 sock_recv_timestamp(msg, &rx->sk, skb);
152 /* receive the message */
153 if (skb->mark != RXRPC_SKB_MARK_DATA)
154 goto receive_non_data_message;
156 _debug("recvmsg DATA #%u { %d, %d }",
157 ntohl(sp->hdr.seq), skb->len, sp->offset);
159 if (!continue_call) {
160 /* only set the control data once per recvmsg() */
161 ret = put_cmsg(msg, SOL_RXRPC, RXRPC_USER_CALL_ID,
162 ullen, &call->user_call_ID);
165 ASSERT(test_bit(RXRPC_CALL_HAS_USERID, &call->flags));
168 ASSERTCMP(ntohl(sp->hdr.seq), >=, call->rx_data_recv);
169 ASSERTCMP(ntohl(sp->hdr.seq), <=, call->rx_data_recv + 1);
170 call->rx_data_recv = ntohl(sp->hdr.seq);
172 ASSERTCMP(ntohl(sp->hdr.seq), >, call->rx_data_eaten);
175 copy = skb->len - offset;
176 if (copy > len - copied)
179 if (skb->ip_summed == CHECKSUM_UNNECESSARY) {
180 ret = skb_copy_datagram_iovec(skb, offset,
183 ret = skb_copy_and_csum_datagram_iovec(skb, offset,
186 goto csum_copy_error;
192 /* handle piecemeal consumption of data packets */
193 _debug("copied %d+%d", copy, copied);
198 if (!(flags & MSG_PEEK))
201 if (sp->offset < skb->len) {
202 _debug("buffer full");
203 ASSERTCMP(copied, ==, len);
207 /* we transferred the whole data packet */
208 if (sp->hdr.flags & RXRPC_LAST_PACKET) {
210 if (call->conn->out_clientflag) {
211 /* last byte of reply received */
213 goto terminal_message;
216 /* last bit of request received */
217 if (!(flags & MSG_PEEK)) {
218 _debug("eat packet");
219 if (skb_dequeue(&rx->sk.sk_receive_queue) !=
224 msg->msg_flags &= ~MSG_MORE;
228 /* move on to the next data message */
231 continue_call = sp->call;
233 rxrpc_put_call(call);
236 if (flags & MSG_PEEK) {
239 if (skb == (struct sk_buff *) &rx->sk.sk_receive_queue)
241 goto peek_next_packet;
244 _debug("eat packet");
245 if (skb_dequeue(&rx->sk.sk_receive_queue) != skb)
250 /* end of non-terminal data packet reception for the moment */
251 _debug("end rcv data");
253 release_sock(&rx->sk);
255 rxrpc_put_call(call);
257 rxrpc_put_call(continue_call);
258 _leave(" = %d [data]", copied);
261 /* handle non-DATA messages such as aborts, incoming connections and
263 receive_non_data_message:
266 if (skb->mark == RXRPC_SKB_MARK_NEW_CALL) {
267 _debug("RECV NEW CALL");
268 ret = put_cmsg(msg, SOL_RXRPC, RXRPC_NEW_CALL, 0, &abort_code);
271 if (!(flags & MSG_PEEK)) {
272 if (skb_dequeue(&rx->sk.sk_receive_queue) != skb)
279 ret = put_cmsg(msg, SOL_RXRPC, RXRPC_USER_CALL_ID,
280 ullen, &call->user_call_ID);
283 ASSERT(test_bit(RXRPC_CALL_HAS_USERID, &call->flags));
286 case RXRPC_SKB_MARK_DATA:
288 case RXRPC_SKB_MARK_FINAL_ACK:
289 ret = put_cmsg(msg, SOL_RXRPC, RXRPC_ACK, 0, &abort_code);
291 case RXRPC_SKB_MARK_BUSY:
292 ret = put_cmsg(msg, SOL_RXRPC, RXRPC_BUSY, 0, &abort_code);
294 case RXRPC_SKB_MARK_REMOTE_ABORT:
295 abort_code = call->abort_code;
296 ret = put_cmsg(msg, SOL_RXRPC, RXRPC_ABORT, 4, &abort_code);
298 case RXRPC_SKB_MARK_NET_ERROR:
299 _debug("RECV NET ERROR %d", sp->error);
300 abort_code = sp->error;
301 ret = put_cmsg(msg, SOL_RXRPC, RXRPC_NET_ERROR, 4, &abort_code);
303 case RXRPC_SKB_MARK_LOCAL_ERROR:
304 _debug("RECV LOCAL ERROR %d", sp->error);
305 abort_code = sp->error;
306 ret = put_cmsg(msg, SOL_RXRPC, RXRPC_LOCAL_ERROR, 4,
319 msg->msg_flags &= ~MSG_MORE;
320 msg->msg_flags |= MSG_EOR;
322 if (!(flags & MSG_PEEK)) {
323 _net("free terminal skb %p", skb);
324 if (skb_dequeue(&rx->sk.sk_receive_queue) != skb)
327 rxrpc_remove_user_ID(rx, call);
330 release_sock(&rx->sk);
331 rxrpc_put_call(call);
333 rxrpc_put_call(continue_call);
334 _leave(" = %d", ret);
338 _debug("copy error");
339 release_sock(&rx->sk);
340 rxrpc_put_call(call);
342 rxrpc_put_call(continue_call);
343 _leave(" = %d", ret);
347 _debug("csum error");
348 release_sock(&rx->sk);
350 rxrpc_put_call(continue_call);
352 skb_kill_datagram(&rx->sk, skb, flags);
353 rxrpc_put_call(call);
357 ret = sock_intr_errno(timeo);
359 finish_wait(rx->sk.sk_sleep, &wait);
361 rxrpc_put_call(continue_call);
364 _leave(" = %d [waitfail %d]", copied, ret);
370 * rxrpc_kernel_data_delivered - Record delivery of data message
371 * @skb: Message holding data
373 * Record the delivery of a data message. This permits RxRPC to keep its
374 * tracking correct. The socket buffer will be deleted.
376 void rxrpc_kernel_data_delivered(struct sk_buff *skb)
378 struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
379 struct rxrpc_call *call = sp->call;
381 ASSERTCMP(ntohl(sp->hdr.seq), >=, call->rx_data_recv);
382 ASSERTCMP(ntohl(sp->hdr.seq), <=, call->rx_data_recv + 1);
383 call->rx_data_recv = ntohl(sp->hdr.seq);
385 ASSERTCMP(ntohl(sp->hdr.seq), >, call->rx_data_eaten);
389 EXPORT_SYMBOL(rxrpc_kernel_data_delivered);
392 * rxrpc_kernel_is_data_last - Determine if data message is last one
393 * @skb: Message holding data
395 * Determine if data message is last one for the parent call.
397 bool rxrpc_kernel_is_data_last(struct sk_buff *skb)
399 struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
401 ASSERTCMP(skb->mark, ==, RXRPC_SKB_MARK_DATA);
403 return sp->hdr.flags & RXRPC_LAST_PACKET;
406 EXPORT_SYMBOL(rxrpc_kernel_is_data_last);
409 * rxrpc_kernel_get_abort_code - Get the abort code from an RxRPC abort message
410 * @skb: Message indicating an abort
412 * Get the abort code from an RxRPC abort message.
414 u32 rxrpc_kernel_get_abort_code(struct sk_buff *skb)
416 struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
418 ASSERTCMP(skb->mark, ==, RXRPC_SKB_MARK_REMOTE_ABORT);
420 return sp->call->abort_code;
423 EXPORT_SYMBOL(rxrpc_kernel_get_abort_code);
426 * rxrpc_kernel_get_error - Get the error number from an RxRPC error message
427 * @skb: Message indicating an error
429 * Get the error number from an RxRPC error message.
431 int rxrpc_kernel_get_error_number(struct sk_buff *skb)
433 struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
438 EXPORT_SYMBOL(rxrpc_kernel_get_error_number);