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 * Apply a hard ACK by advancing the Tx window.
42 static void rxrpc_rotate_tx_window(struct rxrpc_call
*call
, rxrpc_seq_t to
)
44 struct sk_buff
*skb
, *list
= NULL
;
47 spin_lock(&call
->lock
);
49 while (before(call
->tx_hard_ack
, to
)) {
51 ix
= call
->tx_hard_ack
& RXRPC_RXTX_BUFF_MASK
;
52 skb
= call
->rxtx_buffer
[ix
];
54 call
->rxtx_buffer
[ix
] = NULL
;
55 call
->rxtx_annotations
[ix
] = 0;
60 spin_unlock(&call
->lock
);
71 * End the transmission phase of a call.
73 * This occurs when we get an ACKALL packet, the first DATA packet of a reply,
74 * or a final ACK packet.
76 static bool rxrpc_end_tx_phase(struct rxrpc_call
*call
, const char *abort_why
)
80 switch (call
->state
) {
81 case RXRPC_CALL_CLIENT_RECV_REPLY
:
83 case RXRPC_CALL_CLIENT_AWAIT_REPLY
:
84 case RXRPC_CALL_SERVER_AWAIT_ACK
:
87 rxrpc_proto_abort(abort_why
, call
, call
->tx_top
);
91 rxrpc_rotate_tx_window(call
, call
->tx_top
);
93 write_lock(&call
->state_lock
);
95 switch (call
->state
) {
98 case RXRPC_CALL_CLIENT_AWAIT_REPLY
:
99 call
->state
= RXRPC_CALL_CLIENT_RECV_REPLY
;
101 case RXRPC_CALL_SERVER_AWAIT_ACK
:
102 __rxrpc_call_completed(call
);
103 rxrpc_notify_socket(call
);
107 write_unlock(&call
->state_lock
);
113 * Scan a jumbo packet to validate its structure and to work out how many
114 * subpackets it contains.
116 * A jumbo packet is a collection of consecutive packets glued together with
117 * little headers between that indicate how to change the initial header for
120 * RXRPC_JUMBO_PACKET must be set on all but the last subpacket - and all but
121 * the last are RXRPC_JUMBO_DATALEN in size. The last subpacket may be of any
124 static bool rxrpc_validate_jumbo(struct sk_buff
*skb
)
126 struct rxrpc_skb_priv
*sp
= rxrpc_skb(skb
);
127 unsigned int offset
= sp
->offset
;
128 unsigned int len
= skb
->data_len
;
130 u8 flags
= sp
->hdr
.flags
;
134 if (len
- offset
< RXRPC_JUMBO_SUBPKTLEN
)
136 if (flags
& RXRPC_LAST_PACKET
)
138 offset
+= RXRPC_JUMBO_DATALEN
;
139 if (skb_copy_bits(skb
, offset
, &flags
, 1) < 0)
141 offset
+= sizeof(struct rxrpc_jumbo_header
);
142 } while (flags
& RXRPC_JUMBO_PACKET
);
144 sp
->nr_jumbo
= nr_jumbo
;
152 * Handle reception of a duplicate packet.
154 * We have to take care to avoid an attack here whereby we're given a series of
155 * jumbograms, each with a sequence number one before the preceding one and
156 * filled up to maximum UDP size. If they never send us the first packet in
157 * the sequence, they can cause us to have to hold on to around 2MiB of kernel
158 * space until the call times out.
160 * We limit the space usage by only accepting three duplicate jumbo packets per
161 * call. After that, we tell the other side we're no longer accepting jumbos
162 * (that information is encoded in the ACK packet).
164 static void rxrpc_input_dup_data(struct rxrpc_call
*call
, rxrpc_seq_t seq
,
165 u8 annotation
, bool *_jumbo_dup
)
167 /* Discard normal packets that are duplicates. */
171 /* Skip jumbo subpackets that are duplicates. When we've had three or
172 * more partially duplicate jumbo packets, we refuse to take any more
173 * jumbos for this call.
176 call
->nr_jumbo_dup
++;
182 * Process a DATA packet, adding the packet to the Rx ring.
184 static void rxrpc_input_data(struct rxrpc_call
*call
, struct sk_buff
*skb
,
187 struct rxrpc_skb_priv
*sp
= rxrpc_skb(skb
);
188 unsigned int offset
= sp
->offset
;
190 rxrpc_serial_t serial
= sp
->hdr
.serial
, ack_serial
= 0;
191 rxrpc_seq_t seq
= sp
->hdr
.seq
, hard_ack
;
192 bool immediate_ack
= false, jumbo_dup
= false, queued
;
194 u8 ack
= 0, flags
, annotation
= 0;
196 _enter("{%u,%u},{%u,%u}",
197 call
->rx_hard_ack
, call
->rx_top
, skb
->data_len
, seq
);
199 _proto("Rx DATA %%%u { #%u f=%02x }",
200 sp
->hdr
.serial
, seq
, sp
->hdr
.flags
);
202 if (call
->state
>= RXRPC_CALL_COMPLETE
)
205 /* Received data implicitly ACKs all of the request packets we sent
206 * when we're acting as a client.
208 if (call
->state
== RXRPC_CALL_CLIENT_AWAIT_REPLY
&&
209 !rxrpc_end_tx_phase(call
, "ETD"))
212 call
->ackr_prev_seq
= seq
;
214 hard_ack
= READ_ONCE(call
->rx_hard_ack
);
215 if (after(seq
, hard_ack
+ call
->rx_winsize
)) {
216 ack
= RXRPC_ACK_EXCEEDS_WINDOW
;
221 flags
= sp
->hdr
.flags
;
222 if (flags
& RXRPC_JUMBO_PACKET
) {
223 if (call
->nr_jumbo_dup
> 3) {
224 ack
= RXRPC_ACK_NOSPACE
;
233 ix
= seq
& RXRPC_RXTX_BUFF_MASK
;
235 if (flags
& RXRPC_JUMBO_PACKET
)
236 len
= RXRPC_JUMBO_DATALEN
;
238 if (flags
& RXRPC_LAST_PACKET
) {
239 if (test_and_set_bit(RXRPC_CALL_RX_LAST
, &call
->flags
) &&
241 return rxrpc_proto_abort("LSN", call
, seq
);
243 if (test_bit(RXRPC_CALL_RX_LAST
, &call
->flags
) &&
244 after_eq(seq
, call
->rx_top
))
245 return rxrpc_proto_abort("LSA", call
, seq
);
248 if (before_eq(seq
, hard_ack
)) {
249 ack
= RXRPC_ACK_DUPLICATE
;
254 if (flags
& RXRPC_REQUEST_ACK
&& !ack
) {
255 ack
= RXRPC_ACK_REQUESTED
;
259 if (call
->rxtx_buffer
[ix
]) {
260 rxrpc_input_dup_data(call
, seq
, annotation
, &jumbo_dup
);
261 if (ack
!= RXRPC_ACK_DUPLICATE
) {
262 ack
= RXRPC_ACK_DUPLICATE
;
265 immediate_ack
= true;
269 /* Queue the packet. We use a couple of memory barriers here as need
270 * to make sure that rx_top is perceived to be set after the buffer
271 * pointer and that the buffer pointer is set after the annotation and
274 * Barriers against rxrpc_recvmsg_data() and rxrpc_rotate_rx_window()
275 * and also rxrpc_fill_out_ack().
278 call
->rxtx_annotations
[ix
] = annotation
;
280 call
->rxtx_buffer
[ix
] = skb
;
281 if (after(seq
, call
->rx_top
))
282 smp_store_release(&call
->rx_top
, seq
);
285 if (after_eq(seq
, call
->rx_expect_next
)) {
286 if (after(seq
, call
->rx_expect_next
)) {
287 _net("OOS %u > %u", seq
, call
->rx_expect_next
);
288 ack
= RXRPC_ACK_OUT_OF_SEQUENCE
;
291 call
->rx_expect_next
= seq
+ 1;
296 if (flags
& RXRPC_JUMBO_PACKET
) {
297 if (skb_copy_bits(skb
, offset
, &flags
, 1) < 0)
298 return rxrpc_proto_abort("XJF", call
, seq
);
299 offset
+= sizeof(struct rxrpc_jumbo_header
);
303 if (flags
& RXRPC_JUMBO_PACKET
)
304 annotation
|= RXRPC_RX_ANNO_JLAST
;
306 _proto("Rx DATA Jumbo %%%u", serial
);
310 if (queued
&& flags
& RXRPC_LAST_PACKET
&& !ack
) {
311 ack
= RXRPC_ACK_DELAY
;
317 rxrpc_propose_ACK(call
, ack
, skew
, ack_serial
,
318 immediate_ack
, true);
320 if (sp
->hdr
.seq
== READ_ONCE(call
->rx_hard_ack
) + 1)
321 rxrpc_notify_socket(call
);
326 * Process the extra information that may be appended to an ACK packet
328 static void rxrpc_input_ackinfo(struct rxrpc_call
*call
, struct sk_buff
*skb
,
329 struct rxrpc_ackinfo
*ackinfo
)
331 struct rxrpc_skb_priv
*sp
= rxrpc_skb(skb
);
332 struct rxrpc_peer
*peer
;
335 _proto("Rx ACK %%%u Info { rx=%u max=%u rwin=%u jm=%u }",
337 ntohl(ackinfo
->rxMTU
), ntohl(ackinfo
->maxMTU
),
338 ntohl(ackinfo
->rwind
), ntohl(ackinfo
->jumbo_max
));
340 if (call
->tx_winsize
> ntohl(ackinfo
->rwind
))
341 call
->tx_winsize
= ntohl(ackinfo
->rwind
);
343 mtu
= min(ntohl(ackinfo
->rxMTU
), ntohl(ackinfo
->maxMTU
));
346 if (mtu
< peer
->maxdata
) {
347 spin_lock_bh(&peer
->lock
);
349 peer
->mtu
= mtu
+ peer
->hdrsize
;
350 spin_unlock_bh(&peer
->lock
);
351 _net("Net MTU %u (maxdata %u)", peer
->mtu
, peer
->maxdata
);
356 * Process individual soft ACKs.
358 * Each ACK in the array corresponds to one packet and can be either an ACK or
359 * a NAK. If we get find an explicitly NAK'd packet we resend immediately;
360 * packets that lie beyond the end of the ACK list are scheduled for resend by
361 * the timer on the basis that the peer might just not have processed them at
362 * the time the ACK was sent.
364 static void rxrpc_input_soft_acks(struct rxrpc_call
*call
, u8
*acks
,
365 rxrpc_seq_t seq
, int nr_acks
)
370 for (; nr_acks
> 0; nr_acks
--, seq
++) {
371 ix
= seq
& RXRPC_RXTX_BUFF_MASK
;
373 case RXRPC_ACK_TYPE_ACK
:
374 call
->rxtx_annotations
[ix
] = RXRPC_TX_ANNO_ACK
;
376 case RXRPC_ACK_TYPE_NACK
:
377 if (call
->rxtx_annotations
[ix
] == RXRPC_TX_ANNO_NAK
)
379 call
->rxtx_annotations
[ix
] = RXRPC_TX_ANNO_NAK
;
383 return rxrpc_proto_abort("SFT", call
, 0);
388 !test_and_set_bit(RXRPC_CALL_EV_RESEND
, &call
->events
))
389 rxrpc_queue_call(call
);
393 * Process an ACK packet.
395 * ack.firstPacket is the sequence number of the first soft-ACK'd/NAK'd packet
396 * in the ACK array. Anything before that is hard-ACK'd and may be discarded.
398 * A hard-ACK means that a packet has been processed and may be discarded; a
399 * soft-ACK means that the packet may be discarded and retransmission
400 * requested. A phase is complete when all packets are hard-ACK'd.
402 static void rxrpc_input_ack(struct rxrpc_call
*call
, struct sk_buff
*skb
,
405 struct rxrpc_skb_priv
*sp
= rxrpc_skb(skb
);
407 struct rxrpc_ackpacket ack
;
408 struct rxrpc_ackinfo info
;
409 u8 acks
[RXRPC_MAXACKS
];
411 rxrpc_seq_t first_soft_ack
, hard_ack
;
416 if (skb_copy_bits(skb
, sp
->offset
, &buf
.ack
, sizeof(buf
.ack
)) < 0) {
417 _debug("extraction failure");
418 return rxrpc_proto_abort("XAK", call
, 0);
420 sp
->offset
+= sizeof(buf
.ack
);
422 first_soft_ack
= ntohl(buf
.ack
.firstPacket
);
423 hard_ack
= first_soft_ack
- 1;
424 nr_acks
= buf
.ack
.nAcks
;
426 _proto("Rx ACK %%%u { m=%hu f=#%u p=#%u s=%%%u r=%s n=%u }",
428 ntohs(buf
.ack
.maxSkew
),
430 ntohl(buf
.ack
.previousPacket
),
431 ntohl(buf
.ack
.serial
),
432 rxrpc_acks(buf
.ack
.reason
),
435 if (buf
.ack
.reason
== RXRPC_ACK_PING
) {
436 _proto("Rx ACK %%%u PING Request", sp
->hdr
.serial
);
437 rxrpc_propose_ACK(call
, RXRPC_ACK_PING_RESPONSE
,
438 skew
, sp
->hdr
.serial
, true, true);
439 } else if (sp
->hdr
.flags
& RXRPC_REQUEST_ACK
) {
440 rxrpc_propose_ACK(call
, RXRPC_ACK_REQUESTED
,
441 skew
, sp
->hdr
.serial
, true, true);
444 offset
= sp
->offset
+ nr_acks
+ 3;
445 if (skb
->data_len
>= offset
+ sizeof(buf
.info
)) {
446 if (skb_copy_bits(skb
, offset
, &buf
.info
, sizeof(buf
.info
)) < 0)
447 return rxrpc_proto_abort("XAI", call
, 0);
448 rxrpc_input_ackinfo(call
, skb
, &buf
.info
);
451 if (first_soft_ack
== 0)
452 return rxrpc_proto_abort("AK0", call
, 0);
454 /* Ignore ACKs unless we are or have just been transmitting. */
455 switch (call
->state
) {
456 case RXRPC_CALL_CLIENT_SEND_REQUEST
:
457 case RXRPC_CALL_CLIENT_AWAIT_REPLY
:
458 case RXRPC_CALL_SERVER_SEND_REPLY
:
459 case RXRPC_CALL_SERVER_AWAIT_ACK
:
465 /* Discard any out-of-order or duplicate ACKs. */
466 if ((int)sp
->hdr
.serial
- (int)call
->acks_latest
<= 0) {
467 _debug("discard ACK %d <= %d",
468 sp
->hdr
.serial
, call
->acks_latest
);
471 call
->acks_latest
= sp
->hdr
.serial
;
473 if (test_bit(RXRPC_CALL_TX_LAST
, &call
->flags
) &&
474 hard_ack
== call
->tx_top
) {
475 rxrpc_end_tx_phase(call
, "ETA");
479 if (before(hard_ack
, call
->tx_hard_ack
) ||
480 after(hard_ack
, call
->tx_top
))
481 return rxrpc_proto_abort("AKW", call
, 0);
483 if (after(hard_ack
, call
->tx_hard_ack
))
484 rxrpc_rotate_tx_window(call
, hard_ack
);
486 if (after(first_soft_ack
, call
->tx_top
))
489 if (nr_acks
> call
->tx_top
- first_soft_ack
+ 1)
490 nr_acks
= first_soft_ack
- call
->tx_top
+ 1;
491 if (skb_copy_bits(skb
, sp
->offset
, buf
.acks
, nr_acks
) < 0)
492 return rxrpc_proto_abort("XSA", call
, 0);
493 rxrpc_input_soft_acks(call
, buf
.acks
, first_soft_ack
, nr_acks
);
497 * Process an ACKALL packet.
499 static void rxrpc_input_ackall(struct rxrpc_call
*call
, struct sk_buff
*skb
)
501 struct rxrpc_skb_priv
*sp
= rxrpc_skb(skb
);
503 _proto("Rx ACKALL %%%u", sp
->hdr
.serial
);
505 rxrpc_end_tx_phase(call
, "ETL");
509 * Process an ABORT packet.
511 static void rxrpc_input_abort(struct rxrpc_call
*call
, struct sk_buff
*skb
)
513 struct rxrpc_skb_priv
*sp
= rxrpc_skb(skb
);
515 u32 abort_code
= RX_CALL_DEAD
;
520 skb_copy_bits(skb
, sp
->offset
, &wtmp
, sizeof(wtmp
)) >= 0)
521 abort_code
= ntohl(wtmp
);
523 _proto("Rx ABORT %%%u { %x }", sp
->hdr
.serial
, abort_code
);
525 if (rxrpc_set_call_completion(call
, RXRPC_CALL_REMOTELY_ABORTED
,
526 abort_code
, ECONNABORTED
))
527 rxrpc_notify_socket(call
);
531 * Process an incoming call packet.
533 static void rxrpc_input_call_packet(struct rxrpc_call
*call
,
534 struct sk_buff
*skb
, u16 skew
)
536 struct rxrpc_skb_priv
*sp
= rxrpc_skb(skb
);
538 _enter("%p,%p", call
, skb
);
540 switch (sp
->hdr
.type
) {
541 case RXRPC_PACKET_TYPE_DATA
:
542 rxrpc_input_data(call
, skb
, skew
);
545 case RXRPC_PACKET_TYPE_ACK
:
546 rxrpc_input_ack(call
, skb
, skew
);
549 case RXRPC_PACKET_TYPE_BUSY
:
550 _proto("Rx BUSY %%%u", sp
->hdr
.serial
);
552 /* Just ignore BUSY packets from the server; the retry and
553 * lifespan timers will take care of business. BUSY packets
554 * from the client don't make sense.
558 case RXRPC_PACKET_TYPE_ABORT
:
559 rxrpc_input_abort(call
, skb
);
562 case RXRPC_PACKET_TYPE_ACKALL
:
563 rxrpc_input_ackall(call
, skb
);
567 _proto("Rx %s %%%u", rxrpc_pkts
[sp
->hdr
.type
], sp
->hdr
.serial
);
575 * post connection-level events to the connection
576 * - this includes challenges, responses, some aborts and call terminal packet
579 static void rxrpc_post_packet_to_conn(struct rxrpc_connection
*conn
,
582 _enter("%p,%p", conn
, skb
);
584 skb_queue_tail(&conn
->rx_queue
, skb
);
585 rxrpc_queue_conn(conn
);
589 * post endpoint-level events to the local endpoint
590 * - this includes debug and version messages
592 static void rxrpc_post_packet_to_local(struct rxrpc_local
*local
,
595 _enter("%p,%p", local
, skb
);
597 skb_queue_tail(&local
->event_queue
, skb
);
598 rxrpc_queue_local(local
);
602 * put a packet up for transport-level abort
604 static void rxrpc_reject_packet(struct rxrpc_local
*local
, struct sk_buff
*skb
)
606 CHECK_SLAB_OKAY(&local
->usage
);
608 skb_queue_tail(&local
->reject_queue
, skb
);
609 rxrpc_queue_local(local
);
613 * Extract the wire header from a packet and translate the byte order.
616 int rxrpc_extract_header(struct rxrpc_skb_priv
*sp
, struct sk_buff
*skb
)
618 struct rxrpc_wire_header whdr
;
620 /* dig out the RxRPC connection details */
621 if (skb_copy_bits(skb
, 0, &whdr
, sizeof(whdr
)) < 0)
624 memset(sp
, 0, sizeof(*sp
));
625 sp
->hdr
.epoch
= ntohl(whdr
.epoch
);
626 sp
->hdr
.cid
= ntohl(whdr
.cid
);
627 sp
->hdr
.callNumber
= ntohl(whdr
.callNumber
);
628 sp
->hdr
.seq
= ntohl(whdr
.seq
);
629 sp
->hdr
.serial
= ntohl(whdr
.serial
);
630 sp
->hdr
.flags
= whdr
.flags
;
631 sp
->hdr
.type
= whdr
.type
;
632 sp
->hdr
.userStatus
= whdr
.userStatus
;
633 sp
->hdr
.securityIndex
= whdr
.securityIndex
;
634 sp
->hdr
._rsvd
= ntohs(whdr
._rsvd
);
635 sp
->hdr
.serviceId
= ntohs(whdr
.serviceId
);
636 sp
->offset
= sizeof(whdr
);
641 * handle data received on the local endpoint
642 * - may be called in interrupt context
644 * The socket is locked by the caller and this prevents the socket from being
645 * shut down and the local endpoint from going away, thus sk_user_data will not
646 * be cleared until this function returns.
648 void rxrpc_data_ready(struct sock
*udp_sk
)
650 struct rxrpc_connection
*conn
;
651 struct rxrpc_channel
*chan
;
652 struct rxrpc_call
*call
;
653 struct rxrpc_skb_priv
*sp
;
654 struct rxrpc_local
*local
= udp_sk
->sk_user_data
;
656 unsigned int channel
;
659 _enter("%p", udp_sk
);
661 ASSERT(!irqs_disabled());
663 skb
= skb_recv_datagram(udp_sk
, 0, 1, &ret
);
667 _debug("UDP socket error %d", ret
);
673 _net("recv skb %p", skb
);
675 /* we'll probably need to checksum it (didn't call sock_recvmsg) */
676 if (skb_checksum_complete(skb
)) {
678 __UDP_INC_STATS(&init_net
, UDP_MIB_INERRORS
, 0);
679 _leave(" [CSUM failed]");
683 __UDP_INC_STATS(&init_net
, UDP_MIB_INDATAGRAMS
, 0);
685 /* The socket buffer we have is owned by UDP, with UDP's data all over
686 * it, but we really want our own data there.
691 _net("Rx UDP packet from %08x:%04hu",
692 ntohl(ip_hdr(skb
)->saddr
), ntohs(udp_hdr(skb
)->source
));
694 /* dig out the RxRPC connection details */
695 if (rxrpc_extract_header(sp
, skb
) < 0)
697 trace_rxrpc_rx_packet(sp
);
699 _net("Rx RxRPC %s ep=%x call=%x:%x",
700 sp
->hdr
.flags
& RXRPC_CLIENT_INITIATED
? "ToServer" : "ToClient",
701 sp
->hdr
.epoch
, sp
->hdr
.cid
, sp
->hdr
.callNumber
);
703 if (sp
->hdr
.type
>= RXRPC_N_PACKET_TYPES
||
704 !((RXRPC_SUPPORTED_PACKET_TYPES
>> sp
->hdr
.type
) & 1)) {
705 _proto("Rx Bad Packet Type %u", sp
->hdr
.type
);
709 switch (sp
->hdr
.type
) {
710 case RXRPC_PACKET_TYPE_VERSION
:
711 rxrpc_post_packet_to_local(local
, skb
);
714 case RXRPC_PACKET_TYPE_BUSY
:
715 if (sp
->hdr
.flags
& RXRPC_CLIENT_INITIATED
)
718 case RXRPC_PACKET_TYPE_DATA
:
719 if (sp
->hdr
.callNumber
== 0)
721 if (sp
->hdr
.flags
& RXRPC_JUMBO_PACKET
&&
722 !rxrpc_validate_jumbo(skb
))
729 conn
= rxrpc_find_connection_rcu(local
, skb
);
731 if (sp
->hdr
.securityIndex
!= conn
->security_ix
)
734 if (sp
->hdr
.callNumber
== 0) {
735 /* Connection-level packet */
736 _debug("CONN %p {%d}", conn
, conn
->debug_id
);
737 rxrpc_post_packet_to_conn(conn
, skb
);
741 /* Note the serial number skew here */
742 skew
= (int)sp
->hdr
.serial
- (int)conn
->hi_serial
;
745 conn
->hi_serial
= sp
->hdr
.serial
;
748 skew
= min(skew
, 65535);
751 /* Call-bound packets are routed by connection channel. */
752 channel
= sp
->hdr
.cid
& RXRPC_CHANNELMASK
;
753 chan
= &conn
->channels
[channel
];
755 /* Ignore really old calls */
756 if (sp
->hdr
.callNumber
< chan
->last_call
)
759 if (sp
->hdr
.callNumber
== chan
->last_call
) {
760 /* For the previous service call, if completed successfully, we
761 * discard all further packets.
763 if (rxrpc_conn_is_service(conn
) &&
764 (chan
->last_type
== RXRPC_PACKET_TYPE_ACK
||
765 sp
->hdr
.type
== RXRPC_PACKET_TYPE_ABORT
))
768 /* But otherwise we need to retransmit the final packet from
769 * data cached in the connection record.
771 rxrpc_post_packet_to_conn(conn
, skb
);
775 call
= rcu_dereference(chan
->call
);
781 if (!call
|| atomic_read(&call
->usage
) == 0) {
782 if (!(sp
->hdr
.type
& RXRPC_CLIENT_INITIATED
) ||
783 sp
->hdr
.callNumber
== 0 ||
784 sp
->hdr
.type
!= RXRPC_PACKET_TYPE_DATA
)
785 goto bad_message_unlock
;
786 if (sp
->hdr
.seq
!= 1)
788 call
= rxrpc_new_incoming_call(local
, conn
, skb
);
795 rxrpc_input_call_packet(call
, skb
, skew
);
803 trace_rxrpc_rx_done(0, 0);
812 trace_rxrpc_abort("SEC", sp
->hdr
.cid
, sp
->hdr
.callNumber
, sp
->hdr
.seq
,
813 RXKADINCONSISTENCY
, EBADMSG
);
814 skb
->priority
= RXKADINCONSISTENCY
;
820 trace_rxrpc_abort("BAD", sp
->hdr
.cid
, sp
->hdr
.callNumber
, sp
->hdr
.seq
,
821 RX_PROTOCOL_ERROR
, EBADMSG
);
822 skb
->priority
= RX_PROTOCOL_ERROR
;
824 skb
->mark
= RXRPC_SKB_MARK_LOCAL_ABORT
;
826 trace_rxrpc_rx_done(skb
->mark
, skb
->priority
);
827 rxrpc_reject_packet(local
, skb
);