1 /* RxRPC packet reception
3 * Copyright (C) 2007, 2016 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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14 #include <linux/module.h>
15 #include <linux/net.h>
16 #include <linux/skbuff.h>
17 #include <linux/errqueue.h>
18 #include <linux/udp.h>
20 #include <linux/in6.h>
21 #include <linux/icmp.h>
22 #include <linux/gfp.h>
24 #include <net/af_rxrpc.h>
27 #include <net/net_namespace.h>
28 #include "ar-internal.h"
30 static void rxrpc_proto_abort(const char *why
,
31 struct rxrpc_call
*call
, rxrpc_seq_t seq
)
33 if (rxrpc_abort_call(why
, call
, seq
, RX_PROTOCOL_ERROR
, EBADMSG
)) {
34 set_bit(RXRPC_CALL_EV_ABORT
, &call
->events
);
35 rxrpc_queue_call(call
);
40 * Ping the other end to fill our RTT cache and to retrieve the rwind
43 static void rxrpc_send_ping(struct rxrpc_call
*call
, struct sk_buff
*skb
,
46 struct rxrpc_skb_priv
*sp
= rxrpc_skb(skb
);
47 ktime_t now
= skb
->tstamp
;
49 if (call
->peer
->rtt_usage
< 3 ||
50 ktime_before(ktime_add_ms(call
->peer
->rtt_last_req
, 1000), now
))
51 rxrpc_propose_ACK(call
, RXRPC_ACK_PING
, skew
, sp
->hdr
.serial
,
56 * Apply a hard ACK by advancing the Tx window.
58 static void rxrpc_rotate_tx_window(struct rxrpc_call
*call
, rxrpc_seq_t to
)
60 struct sk_buff
*skb
, *list
= NULL
;
63 spin_lock(&call
->lock
);
65 while (before(call
->tx_hard_ack
, to
)) {
67 ix
= call
->tx_hard_ack
& RXRPC_RXTX_BUFF_MASK
;
68 skb
= call
->rxtx_buffer
[ix
];
69 rxrpc_see_skb(skb
, rxrpc_skb_tx_rotated
);
70 call
->rxtx_buffer
[ix
] = NULL
;
71 call
->rxtx_annotations
[ix
] = 0;
76 spin_unlock(&call
->lock
);
78 trace_rxrpc_transmit(call
, rxrpc_transmit_rotate
);
79 wake_up(&call
->waitq
);
85 rxrpc_free_skb(skb
, rxrpc_skb_tx_freed
);
90 * End the transmission phase of a call.
92 * This occurs when we get an ACKALL packet, the first DATA packet of a reply,
93 * or a final ACK packet.
95 static bool rxrpc_end_tx_phase(struct rxrpc_call
*call
, const char *abort_why
)
99 switch (call
->state
) {
100 case RXRPC_CALL_CLIENT_RECV_REPLY
:
102 case RXRPC_CALL_CLIENT_AWAIT_REPLY
:
103 case RXRPC_CALL_SERVER_AWAIT_ACK
:
106 rxrpc_proto_abort(abort_why
, call
, call
->tx_top
);
110 rxrpc_rotate_tx_window(call
, call
->tx_top
);
112 write_lock(&call
->state_lock
);
114 switch (call
->state
) {
117 case RXRPC_CALL_CLIENT_AWAIT_REPLY
:
118 call
->tx_phase
= false;
119 call
->state
= RXRPC_CALL_CLIENT_RECV_REPLY
;
121 case RXRPC_CALL_SERVER_AWAIT_ACK
:
122 __rxrpc_call_completed(call
);
123 rxrpc_notify_socket(call
);
127 write_unlock(&call
->state_lock
);
128 trace_rxrpc_transmit(call
, rxrpc_transmit_end
);
134 * Scan a jumbo packet to validate its structure and to work out how many
135 * subpackets it contains.
137 * A jumbo packet is a collection of consecutive packets glued together with
138 * little headers between that indicate how to change the initial header for
141 * RXRPC_JUMBO_PACKET must be set on all but the last subpacket - and all but
142 * the last are RXRPC_JUMBO_DATALEN in size. The last subpacket may be of any
145 static bool rxrpc_validate_jumbo(struct sk_buff
*skb
)
147 struct rxrpc_skb_priv
*sp
= rxrpc_skb(skb
);
148 unsigned int offset
= sp
->offset
;
149 unsigned int len
= skb
->len
;
151 u8 flags
= sp
->hdr
.flags
;
155 if (len
- offset
< RXRPC_JUMBO_SUBPKTLEN
)
157 if (flags
& RXRPC_LAST_PACKET
)
159 offset
+= RXRPC_JUMBO_DATALEN
;
160 if (skb_copy_bits(skb
, offset
, &flags
, 1) < 0)
162 offset
+= sizeof(struct rxrpc_jumbo_header
);
163 } while (flags
& RXRPC_JUMBO_PACKET
);
165 sp
->nr_jumbo
= nr_jumbo
;
173 * Handle reception of a duplicate packet.
175 * We have to take care to avoid an attack here whereby we're given a series of
176 * jumbograms, each with a sequence number one before the preceding one and
177 * filled up to maximum UDP size. If they never send us the first packet in
178 * the sequence, they can cause us to have to hold on to around 2MiB of kernel
179 * space until the call times out.
181 * We limit the space usage by only accepting three duplicate jumbo packets per
182 * call. After that, we tell the other side we're no longer accepting jumbos
183 * (that information is encoded in the ACK packet).
185 static void rxrpc_input_dup_data(struct rxrpc_call
*call
, rxrpc_seq_t seq
,
186 u8 annotation
, bool *_jumbo_bad
)
188 /* Discard normal packets that are duplicates. */
192 /* Skip jumbo subpackets that are duplicates. When we've had three or
193 * more partially duplicate jumbo packets, we refuse to take any more
194 * jumbos for this call.
197 call
->nr_jumbo_bad
++;
203 * Process a DATA packet, adding the packet to the Rx ring.
205 static void rxrpc_input_data(struct rxrpc_call
*call
, struct sk_buff
*skb
,
208 struct rxrpc_skb_priv
*sp
= rxrpc_skb(skb
);
209 unsigned int offset
= sp
->offset
;
211 rxrpc_serial_t serial
= sp
->hdr
.serial
, ack_serial
= 0;
212 rxrpc_seq_t seq
= sp
->hdr
.seq
, hard_ack
;
213 bool immediate_ack
= false, jumbo_bad
= false, queued
;
215 u8 ack
= 0, flags
, annotation
= 0;
217 _enter("{%u,%u},{%u,%u}",
218 call
->rx_hard_ack
, call
->rx_top
, skb
->len
, seq
);
220 _proto("Rx DATA %%%u { #%u f=%02x }",
221 sp
->hdr
.serial
, seq
, sp
->hdr
.flags
);
223 if (call
->state
>= RXRPC_CALL_COMPLETE
)
226 /* Received data implicitly ACKs all of the request packets we sent
227 * when we're acting as a client.
229 if (call
->state
== RXRPC_CALL_CLIENT_AWAIT_REPLY
&&
230 !rxrpc_end_tx_phase(call
, "ETD"))
233 call
->ackr_prev_seq
= seq
;
235 hard_ack
= READ_ONCE(call
->rx_hard_ack
);
236 if (after(seq
, hard_ack
+ call
->rx_winsize
)) {
237 ack
= RXRPC_ACK_EXCEEDS_WINDOW
;
242 flags
= sp
->hdr
.flags
;
243 if (flags
& RXRPC_JUMBO_PACKET
) {
244 if (call
->nr_jumbo_bad
> 3) {
245 ack
= RXRPC_ACK_NOSPACE
;
254 ix
= seq
& RXRPC_RXTX_BUFF_MASK
;
256 if (flags
& RXRPC_JUMBO_PACKET
)
257 len
= RXRPC_JUMBO_DATALEN
;
259 if (flags
& RXRPC_LAST_PACKET
) {
260 if (test_bit(RXRPC_CALL_RX_LAST
, &call
->flags
) &&
262 return rxrpc_proto_abort("LSN", call
, seq
);
264 if (test_bit(RXRPC_CALL_RX_LAST
, &call
->flags
) &&
265 after_eq(seq
, call
->rx_top
))
266 return rxrpc_proto_abort("LSA", call
, seq
);
269 if (before_eq(seq
, hard_ack
)) {
270 ack
= RXRPC_ACK_DUPLICATE
;
275 if (flags
& RXRPC_REQUEST_ACK
&& !ack
) {
276 ack
= RXRPC_ACK_REQUESTED
;
280 if (call
->rxtx_buffer
[ix
]) {
281 rxrpc_input_dup_data(call
, seq
, annotation
, &jumbo_bad
);
282 if (ack
!= RXRPC_ACK_DUPLICATE
) {
283 ack
= RXRPC_ACK_DUPLICATE
;
286 immediate_ack
= true;
290 /* Queue the packet. We use a couple of memory barriers here as need
291 * to make sure that rx_top is perceived to be set after the buffer
292 * pointer and that the buffer pointer is set after the annotation and
295 * Barriers against rxrpc_recvmsg_data() and rxrpc_rotate_rx_window()
296 * and also rxrpc_fill_out_ack().
298 rxrpc_get_skb(skb
, rxrpc_skb_rx_got
);
299 call
->rxtx_annotations
[ix
] = annotation
;
301 call
->rxtx_buffer
[ix
] = skb
;
302 if (after(seq
, call
->rx_top
))
303 smp_store_release(&call
->rx_top
, seq
);
304 if (flags
& RXRPC_LAST_PACKET
) {
305 set_bit(RXRPC_CALL_RX_LAST
, &call
->flags
);
306 trace_rxrpc_receive(call
, rxrpc_receive_queue_last
, serial
, seq
);
308 trace_rxrpc_receive(call
, rxrpc_receive_queue
, serial
, seq
);
312 if (after_eq(seq
, call
->rx_expect_next
)) {
313 if (after(seq
, call
->rx_expect_next
)) {
314 _net("OOS %u > %u", seq
, call
->rx_expect_next
);
315 ack
= RXRPC_ACK_OUT_OF_SEQUENCE
;
318 call
->rx_expect_next
= seq
+ 1;
323 if (flags
& RXRPC_JUMBO_PACKET
) {
324 if (skb_copy_bits(skb
, offset
, &flags
, 1) < 0)
325 return rxrpc_proto_abort("XJF", call
, seq
);
326 offset
+= sizeof(struct rxrpc_jumbo_header
);
330 if (flags
& RXRPC_JUMBO_PACKET
)
331 annotation
|= RXRPC_RX_ANNO_JLAST
;
332 if (after(seq
, hard_ack
+ call
->rx_winsize
)) {
333 ack
= RXRPC_ACK_EXCEEDS_WINDOW
;
336 call
->nr_jumbo_bad
++;
342 _proto("Rx DATA Jumbo %%%u", serial
);
346 if (queued
&& flags
& RXRPC_LAST_PACKET
&& !ack
) {
347 ack
= RXRPC_ACK_DELAY
;
353 rxrpc_propose_ACK(call
, ack
, skew
, ack_serial
,
354 immediate_ack
, true);
356 if (sp
->hdr
.seq
== READ_ONCE(call
->rx_hard_ack
) + 1)
357 rxrpc_notify_socket(call
);
362 * Process a requested ACK.
364 static void rxrpc_input_requested_ack(struct rxrpc_call
*call
,
366 rxrpc_serial_t orig_serial
,
367 rxrpc_serial_t ack_serial
)
369 struct rxrpc_skb_priv
*sp
;
374 for (ix
= 0; ix
< RXRPC_RXTX_BUFF_SIZE
; ix
++) {
375 skb
= call
->rxtx_buffer
[ix
];
380 if (sp
->hdr
.serial
!= orig_serial
)
383 sent_at
= skb
->tstamp
;
389 rxrpc_peer_add_rtt(call
, rxrpc_rtt_rx_requested_ack
,
390 orig_serial
, ack_serial
, sent_at
, resp_time
);
394 * Process a ping response.
396 static void rxrpc_input_ping_response(struct rxrpc_call
*call
,
398 rxrpc_serial_t orig_serial
,
399 rxrpc_serial_t ack_serial
)
401 rxrpc_serial_t ping_serial
;
404 ping_time
= call
->ackr_ping_time
;
406 ping_serial
= call
->ackr_ping
;
408 if (!test_bit(RXRPC_CALL_PINGING
, &call
->flags
) ||
409 before(orig_serial
, ping_serial
))
411 clear_bit(RXRPC_CALL_PINGING
, &call
->flags
);
412 if (after(orig_serial
, ping_serial
))
415 rxrpc_peer_add_rtt(call
, rxrpc_rtt_rx_ping_response
,
416 orig_serial
, ack_serial
, ping_time
, resp_time
);
420 * Process the extra information that may be appended to an ACK packet
422 static void rxrpc_input_ackinfo(struct rxrpc_call
*call
, struct sk_buff
*skb
,
423 struct rxrpc_ackinfo
*ackinfo
)
425 struct rxrpc_skb_priv
*sp
= rxrpc_skb(skb
);
426 struct rxrpc_peer
*peer
;
428 u32 rwind
= ntohl(ackinfo
->rwind
);
430 _proto("Rx ACK %%%u Info { rx=%u max=%u rwin=%u jm=%u }",
432 ntohl(ackinfo
->rxMTU
), ntohl(ackinfo
->maxMTU
),
433 rwind
, ntohl(ackinfo
->jumbo_max
));
435 if (rwind
> RXRPC_RXTX_BUFF_SIZE
- 1)
436 rwind
= RXRPC_RXTX_BUFF_SIZE
- 1;
437 call
->tx_winsize
= rwind
;
439 mtu
= min(ntohl(ackinfo
->rxMTU
), ntohl(ackinfo
->maxMTU
));
442 if (mtu
< peer
->maxdata
) {
443 spin_lock_bh(&peer
->lock
);
445 peer
->mtu
= mtu
+ peer
->hdrsize
;
446 spin_unlock_bh(&peer
->lock
);
447 _net("Net MTU %u (maxdata %u)", peer
->mtu
, peer
->maxdata
);
452 * Process individual soft ACKs.
454 * Each ACK in the array corresponds to one packet and can be either an ACK or
455 * a NAK. If we get find an explicitly NAK'd packet we resend immediately;
456 * packets that lie beyond the end of the ACK list are scheduled for resend by
457 * the timer on the basis that the peer might just not have processed them at
458 * the time the ACK was sent.
460 static void rxrpc_input_soft_acks(struct rxrpc_call
*call
, u8
*acks
,
461 rxrpc_seq_t seq
, int nr_acks
)
465 u8 annotation
, anno_type
;
467 for (; nr_acks
> 0; nr_acks
--, seq
++) {
468 ix
= seq
& RXRPC_RXTX_BUFF_MASK
;
469 annotation
= call
->rxtx_annotations
[ix
];
470 anno_type
= annotation
& RXRPC_TX_ANNO_MASK
;
471 annotation
&= ~RXRPC_TX_ANNO_MASK
;
473 case RXRPC_ACK_TYPE_ACK
:
474 if (anno_type
== RXRPC_TX_ANNO_ACK
)
476 call
->rxtx_annotations
[ix
] =
477 RXRPC_TX_ANNO_ACK
| annotation
;
479 case RXRPC_ACK_TYPE_NACK
:
480 if (anno_type
== RXRPC_TX_ANNO_NAK
)
482 if (anno_type
== RXRPC_TX_ANNO_RETRANS
)
484 call
->rxtx_annotations
[ix
] =
485 RXRPC_TX_ANNO_NAK
| annotation
;
489 return rxrpc_proto_abort("SFT", call
, 0);
494 !test_and_set_bit(RXRPC_CALL_EV_RESEND
, &call
->events
))
495 rxrpc_queue_call(call
);
499 * Process an ACK packet.
501 * ack.firstPacket is the sequence number of the first soft-ACK'd/NAK'd packet
502 * in the ACK array. Anything before that is hard-ACK'd and may be discarded.
504 * A hard-ACK means that a packet has been processed and may be discarded; a
505 * soft-ACK means that the packet may be discarded and retransmission
506 * requested. A phase is complete when all packets are hard-ACK'd.
508 static void rxrpc_input_ack(struct rxrpc_call
*call
, struct sk_buff
*skb
,
511 struct rxrpc_skb_priv
*sp
= rxrpc_skb(skb
);
513 struct rxrpc_ackpacket ack
;
514 struct rxrpc_ackinfo info
;
515 u8 acks
[RXRPC_MAXACKS
];
517 rxrpc_serial_t acked_serial
;
518 rxrpc_seq_t first_soft_ack
, hard_ack
;
523 if (skb_copy_bits(skb
, sp
->offset
, &buf
.ack
, sizeof(buf
.ack
)) < 0) {
524 _debug("extraction failure");
525 return rxrpc_proto_abort("XAK", call
, 0);
527 sp
->offset
+= sizeof(buf
.ack
);
529 acked_serial
= ntohl(buf
.ack
.serial
);
530 first_soft_ack
= ntohl(buf
.ack
.firstPacket
);
531 hard_ack
= first_soft_ack
- 1;
532 nr_acks
= buf
.ack
.nAcks
;
534 trace_rxrpc_rx_ack(call
, first_soft_ack
, buf
.ack
.reason
, nr_acks
);
536 _proto("Rx ACK %%%u { m=%hu f=#%u p=#%u s=%%%u r=%s n=%u }",
538 ntohs(buf
.ack
.maxSkew
),
540 ntohl(buf
.ack
.previousPacket
),
542 rxrpc_acks(buf
.ack
.reason
),
545 if (buf
.ack
.reason
== RXRPC_ACK_PING_RESPONSE
)
546 rxrpc_input_ping_response(call
, skb
->tstamp
, acked_serial
,
548 if (buf
.ack
.reason
== RXRPC_ACK_REQUESTED
)
549 rxrpc_input_requested_ack(call
, skb
->tstamp
, acked_serial
,
552 if (buf
.ack
.reason
== RXRPC_ACK_PING
) {
553 _proto("Rx ACK %%%u PING Request", sp
->hdr
.serial
);
554 rxrpc_propose_ACK(call
, RXRPC_ACK_PING_RESPONSE
,
555 skew
, sp
->hdr
.serial
, true, true);
556 } else if (sp
->hdr
.flags
& RXRPC_REQUEST_ACK
) {
557 rxrpc_propose_ACK(call
, RXRPC_ACK_REQUESTED
,
558 skew
, sp
->hdr
.serial
, true, true);
561 offset
= sp
->offset
+ nr_acks
+ 3;
562 if (skb
->len
>= offset
+ sizeof(buf
.info
)) {
563 if (skb_copy_bits(skb
, offset
, &buf
.info
, sizeof(buf
.info
)) < 0)
564 return rxrpc_proto_abort("XAI", call
, 0);
565 rxrpc_input_ackinfo(call
, skb
, &buf
.info
);
568 if (first_soft_ack
== 0)
569 return rxrpc_proto_abort("AK0", call
, 0);
571 /* Ignore ACKs unless we are or have just been transmitting. */
572 switch (call
->state
) {
573 case RXRPC_CALL_CLIENT_SEND_REQUEST
:
574 case RXRPC_CALL_CLIENT_AWAIT_REPLY
:
575 case RXRPC_CALL_SERVER_SEND_REPLY
:
576 case RXRPC_CALL_SERVER_AWAIT_ACK
:
582 /* Discard any out-of-order or duplicate ACKs. */
583 if (before_eq(sp
->hdr
.serial
, call
->acks_latest
)) {
584 _debug("discard ACK %d <= %d",
585 sp
->hdr
.serial
, call
->acks_latest
);
588 call
->acks_latest
= sp
->hdr
.serial
;
590 if (test_bit(RXRPC_CALL_TX_LAST
, &call
->flags
) &&
591 hard_ack
== call
->tx_top
) {
592 rxrpc_end_tx_phase(call
, "ETA");
596 if (before(hard_ack
, call
->tx_hard_ack
) ||
597 after(hard_ack
, call
->tx_top
))
598 return rxrpc_proto_abort("AKW", call
, 0);
600 if (after(hard_ack
, call
->tx_hard_ack
))
601 rxrpc_rotate_tx_window(call
, hard_ack
);
603 if (after(first_soft_ack
, call
->tx_top
))
606 if (nr_acks
> call
->tx_top
- first_soft_ack
+ 1)
607 nr_acks
= first_soft_ack
- call
->tx_top
+ 1;
608 if (skb_copy_bits(skb
, sp
->offset
, buf
.acks
, nr_acks
) < 0)
609 return rxrpc_proto_abort("XSA", call
, 0);
610 rxrpc_input_soft_acks(call
, buf
.acks
, first_soft_ack
, nr_acks
);
614 * Process an ACKALL packet.
616 static void rxrpc_input_ackall(struct rxrpc_call
*call
, struct sk_buff
*skb
)
618 struct rxrpc_skb_priv
*sp
= rxrpc_skb(skb
);
620 _proto("Rx ACKALL %%%u", sp
->hdr
.serial
);
622 rxrpc_end_tx_phase(call
, "ETL");
626 * Process an ABORT packet.
628 static void rxrpc_input_abort(struct rxrpc_call
*call
, struct sk_buff
*skb
)
630 struct rxrpc_skb_priv
*sp
= rxrpc_skb(skb
);
632 u32 abort_code
= RX_CALL_DEAD
;
637 skb_copy_bits(skb
, sp
->offset
, &wtmp
, sizeof(wtmp
)) >= 0)
638 abort_code
= ntohl(wtmp
);
640 _proto("Rx ABORT %%%u { %x }", sp
->hdr
.serial
, abort_code
);
642 if (rxrpc_set_call_completion(call
, RXRPC_CALL_REMOTELY_ABORTED
,
643 abort_code
, ECONNABORTED
))
644 rxrpc_notify_socket(call
);
648 * Process an incoming call packet.
650 static void rxrpc_input_call_packet(struct rxrpc_call
*call
,
651 struct sk_buff
*skb
, u16 skew
)
653 struct rxrpc_skb_priv
*sp
= rxrpc_skb(skb
);
655 _enter("%p,%p", call
, skb
);
657 switch (sp
->hdr
.type
) {
658 case RXRPC_PACKET_TYPE_DATA
:
659 rxrpc_input_data(call
, skb
, skew
);
662 case RXRPC_PACKET_TYPE_ACK
:
663 rxrpc_input_ack(call
, skb
, skew
);
666 case RXRPC_PACKET_TYPE_BUSY
:
667 _proto("Rx BUSY %%%u", sp
->hdr
.serial
);
669 /* Just ignore BUSY packets from the server; the retry and
670 * lifespan timers will take care of business. BUSY packets
671 * from the client don't make sense.
675 case RXRPC_PACKET_TYPE_ABORT
:
676 rxrpc_input_abort(call
, skb
);
679 case RXRPC_PACKET_TYPE_ACKALL
:
680 rxrpc_input_ackall(call
, skb
);
684 _proto("Rx %s %%%u", rxrpc_pkts
[sp
->hdr
.type
], sp
->hdr
.serial
);
692 * post connection-level events to the connection
693 * - this includes challenges, responses, some aborts and call terminal packet
696 static void rxrpc_post_packet_to_conn(struct rxrpc_connection
*conn
,
699 _enter("%p,%p", conn
, skb
);
701 skb_queue_tail(&conn
->rx_queue
, skb
);
702 rxrpc_queue_conn(conn
);
706 * post endpoint-level events to the local endpoint
707 * - this includes debug and version messages
709 static void rxrpc_post_packet_to_local(struct rxrpc_local
*local
,
712 _enter("%p,%p", local
, skb
);
714 skb_queue_tail(&local
->event_queue
, skb
);
715 rxrpc_queue_local(local
);
719 * put a packet up for transport-level abort
721 static void rxrpc_reject_packet(struct rxrpc_local
*local
, struct sk_buff
*skb
)
723 CHECK_SLAB_OKAY(&local
->usage
);
725 skb_queue_tail(&local
->reject_queue
, skb
);
726 rxrpc_queue_local(local
);
730 * Extract the wire header from a packet and translate the byte order.
733 int rxrpc_extract_header(struct rxrpc_skb_priv
*sp
, struct sk_buff
*skb
)
735 struct rxrpc_wire_header whdr
;
737 /* dig out the RxRPC connection details */
738 if (skb_copy_bits(skb
, 0, &whdr
, sizeof(whdr
)) < 0)
741 memset(sp
, 0, sizeof(*sp
));
742 sp
->hdr
.epoch
= ntohl(whdr
.epoch
);
743 sp
->hdr
.cid
= ntohl(whdr
.cid
);
744 sp
->hdr
.callNumber
= ntohl(whdr
.callNumber
);
745 sp
->hdr
.seq
= ntohl(whdr
.seq
);
746 sp
->hdr
.serial
= ntohl(whdr
.serial
);
747 sp
->hdr
.flags
= whdr
.flags
;
748 sp
->hdr
.type
= whdr
.type
;
749 sp
->hdr
.userStatus
= whdr
.userStatus
;
750 sp
->hdr
.securityIndex
= whdr
.securityIndex
;
751 sp
->hdr
._rsvd
= ntohs(whdr
._rsvd
);
752 sp
->hdr
.serviceId
= ntohs(whdr
.serviceId
);
753 sp
->offset
= sizeof(whdr
);
758 * handle data received on the local endpoint
759 * - may be called in interrupt context
761 * The socket is locked by the caller and this prevents the socket from being
762 * shut down and the local endpoint from going away, thus sk_user_data will not
763 * be cleared until this function returns.
765 void rxrpc_data_ready(struct sock
*udp_sk
)
767 struct rxrpc_connection
*conn
;
768 struct rxrpc_channel
*chan
;
769 struct rxrpc_call
*call
;
770 struct rxrpc_skb_priv
*sp
;
771 struct rxrpc_local
*local
= udp_sk
->sk_user_data
;
773 unsigned int channel
;
776 _enter("%p", udp_sk
);
778 ASSERT(!irqs_disabled());
780 skb
= skb_recv_datagram(udp_sk
, 0, 1, &ret
);
784 _debug("UDP socket error %d", ret
);
788 rxrpc_new_skb(skb
, rxrpc_skb_rx_received
);
790 _net("recv skb %p", skb
);
792 /* we'll probably need to checksum it (didn't call sock_recvmsg) */
793 if (skb_checksum_complete(skb
)) {
794 rxrpc_free_skb(skb
, rxrpc_skb_rx_freed
);
795 __UDP_INC_STATS(&init_net
, UDP_MIB_INERRORS
, 0);
796 _leave(" [CSUM failed]");
800 __UDP_INC_STATS(&init_net
, UDP_MIB_INDATAGRAMS
, 0);
802 /* The socket buffer we have is owned by UDP, with UDP's data all over
803 * it, but we really want our own data there.
808 if (IS_ENABLED(CONFIG_AF_RXRPC_INJECT_LOSS
)) {
810 if ((lose
++ & 7) == 7) {
811 rxrpc_lose_skb(skb
, rxrpc_skb_rx_lost
);
816 _net("Rx UDP packet from %08x:%04hu",
817 ntohl(ip_hdr(skb
)->saddr
), ntohs(udp_hdr(skb
)->source
));
819 /* dig out the RxRPC connection details */
820 if (rxrpc_extract_header(sp
, skb
) < 0)
822 trace_rxrpc_rx_packet(sp
);
824 _net("Rx RxRPC %s ep=%x call=%x:%x",
825 sp
->hdr
.flags
& RXRPC_CLIENT_INITIATED
? "ToServer" : "ToClient",
826 sp
->hdr
.epoch
, sp
->hdr
.cid
, sp
->hdr
.callNumber
);
828 if (sp
->hdr
.type
>= RXRPC_N_PACKET_TYPES
||
829 !((RXRPC_SUPPORTED_PACKET_TYPES
>> sp
->hdr
.type
) & 1)) {
830 _proto("Rx Bad Packet Type %u", sp
->hdr
.type
);
834 switch (sp
->hdr
.type
) {
835 case RXRPC_PACKET_TYPE_VERSION
:
836 rxrpc_post_packet_to_local(local
, skb
);
839 case RXRPC_PACKET_TYPE_BUSY
:
840 if (sp
->hdr
.flags
& RXRPC_CLIENT_INITIATED
)
843 case RXRPC_PACKET_TYPE_DATA
:
844 if (sp
->hdr
.callNumber
== 0)
846 if (sp
->hdr
.flags
& RXRPC_JUMBO_PACKET
&&
847 !rxrpc_validate_jumbo(skb
))
854 conn
= rxrpc_find_connection_rcu(local
, skb
);
856 if (sp
->hdr
.securityIndex
!= conn
->security_ix
)
859 if (sp
->hdr
.callNumber
== 0) {
860 /* Connection-level packet */
861 _debug("CONN %p {%d}", conn
, conn
->debug_id
);
862 rxrpc_post_packet_to_conn(conn
, skb
);
866 /* Note the serial number skew here */
867 skew
= (int)sp
->hdr
.serial
- (int)conn
->hi_serial
;
870 conn
->hi_serial
= sp
->hdr
.serial
;
873 skew
= min(skew
, 65535);
876 /* Call-bound packets are routed by connection channel. */
877 channel
= sp
->hdr
.cid
& RXRPC_CHANNELMASK
;
878 chan
= &conn
->channels
[channel
];
880 /* Ignore really old calls */
881 if (sp
->hdr
.callNumber
< chan
->last_call
)
884 if (sp
->hdr
.callNumber
== chan
->last_call
) {
885 /* For the previous service call, if completed successfully, we
886 * discard all further packets.
888 if (rxrpc_conn_is_service(conn
) &&
889 (chan
->last_type
== RXRPC_PACKET_TYPE_ACK
||
890 sp
->hdr
.type
== RXRPC_PACKET_TYPE_ABORT
))
893 /* But otherwise we need to retransmit the final packet from
894 * data cached in the connection record.
896 rxrpc_post_packet_to_conn(conn
, skb
);
900 call
= rcu_dereference(chan
->call
);
906 if (!call
|| atomic_read(&call
->usage
) == 0) {
907 if (!(sp
->hdr
.type
& RXRPC_CLIENT_INITIATED
) ||
908 sp
->hdr
.callNumber
== 0 ||
909 sp
->hdr
.type
!= RXRPC_PACKET_TYPE_DATA
)
910 goto bad_message_unlock
;
911 if (sp
->hdr
.seq
!= 1)
913 call
= rxrpc_new_incoming_call(local
, conn
, skb
);
918 rxrpc_send_ping(call
, skb
, skew
);
921 rxrpc_input_call_packet(call
, skb
, skew
);
927 rxrpc_free_skb(skb
, rxrpc_skb_rx_freed
);
929 trace_rxrpc_rx_done(0, 0);
938 trace_rxrpc_abort("SEC", sp
->hdr
.cid
, sp
->hdr
.callNumber
, sp
->hdr
.seq
,
939 RXKADINCONSISTENCY
, EBADMSG
);
940 skb
->priority
= RXKADINCONSISTENCY
;
946 trace_rxrpc_abort("BAD", sp
->hdr
.cid
, sp
->hdr
.callNumber
, sp
->hdr
.seq
,
947 RX_PROTOCOL_ERROR
, EBADMSG
);
948 skb
->priority
= RX_PROTOCOL_ERROR
;
950 skb
->mark
= RXRPC_SKB_MARK_LOCAL_ABORT
;
952 trace_rxrpc_rx_done(skb
->mark
, skb
->priority
);
953 rxrpc_reject_packet(local
, skb
);