Commit | Line | Data |
---|---|---|
2874c5fd | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
f66d7490 | 2 | /* Peer event handling, typically ICMP messages. |
17926a79 DH |
3 | * |
4 | * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved. | |
5 | * Written by David Howells (dhowells@redhat.com) | |
17926a79 DH |
6 | */ |
7 | ||
8 | #include <linux/module.h> | |
9 | #include <linux/net.h> | |
10 | #include <linux/skbuff.h> | |
11 | #include <linux/errqueue.h> | |
12 | #include <linux/udp.h> | |
13 | #include <linux/in.h> | |
14 | #include <linux/in6.h> | |
15 | #include <linux/icmp.h> | |
16 | #include <net/sock.h> | |
17 | #include <net/af_rxrpc.h> | |
18 | #include <net/ip.h> | |
19 | #include "ar-internal.h" | |
20 | ||
5e6ef4f1 DH |
21 | static void rxrpc_store_error(struct rxrpc_peer *, struct sk_buff *); |
22 | static void rxrpc_distribute_error(struct rxrpc_peer *, struct sk_buff *, | |
23 | enum rxrpc_call_completion, int); | |
f66d7490 | 24 | |
ac56a0b4 DH |
25 | /* |
26 | * Find the peer associated with a local error. | |
27 | */ | |
28 | static struct rxrpc_peer *rxrpc_lookup_peer_local_rcu(struct rxrpc_local *local, | |
29 | const struct sk_buff *skb, | |
30 | struct sockaddr_rxrpc *srx) | |
31 | { | |
32 | struct sock_exterr_skb *serr = SKB_EXT_ERR(skb); | |
33 | ||
34 | _enter(""); | |
35 | ||
36 | memset(srx, 0, sizeof(*srx)); | |
37 | srx->transport_type = local->srx.transport_type; | |
38 | srx->transport_len = local->srx.transport_len; | |
39 | srx->transport.family = local->srx.transport.family; | |
40 | ||
b6c66c43 DH |
41 | /* Can we see an ICMP4 packet on an ICMP6 listening socket? and vice |
42 | * versa? | |
43 | */ | |
494337c9 | 44 | switch (srx->transport.family) { |
be6e6707 | 45 | case AF_INET: |
46894a13 DH |
46 | srx->transport_len = sizeof(srx->transport.sin); |
47 | srx->transport.family = AF_INET; | |
494337c9 | 48 | srx->transport.sin.sin_port = serr->port; |
be6e6707 DH |
49 | switch (serr->ee.ee_origin) { |
50 | case SO_EE_ORIGIN_ICMP: | |
494337c9 | 51 | memcpy(&srx->transport.sin.sin_addr, |
be6e6707 DH |
52 | skb_network_header(skb) + serr->addr_offset, |
53 | sizeof(struct in_addr)); | |
54 | break; | |
55 | case SO_EE_ORIGIN_ICMP6: | |
494337c9 | 56 | memcpy(&srx->transport.sin.sin_addr, |
be6e6707 DH |
57 | skb_network_header(skb) + serr->addr_offset + 12, |
58 | sizeof(struct in_addr)); | |
59 | break; | |
60 | default: | |
494337c9 | 61 | memcpy(&srx->transport.sin.sin_addr, &ip_hdr(skb)->saddr, |
be6e6707 DH |
62 | sizeof(struct in_addr)); |
63 | break; | |
64 | } | |
65 | break; | |
66 | ||
d1912747 | 67 | #ifdef CONFIG_AF_RXRPC_IPV6 |
75b54cb5 | 68 | case AF_INET6: |
75b54cb5 DH |
69 | switch (serr->ee.ee_origin) { |
70 | case SO_EE_ORIGIN_ICMP6: | |
46894a13 | 71 | srx->transport.sin6.sin6_port = serr->port; |
494337c9 | 72 | memcpy(&srx->transport.sin6.sin6_addr, |
75b54cb5 DH |
73 | skb_network_header(skb) + serr->addr_offset, |
74 | sizeof(struct in6_addr)); | |
75 | break; | |
76 | case SO_EE_ORIGIN_ICMP: | |
46894a13 DH |
77 | srx->transport_len = sizeof(srx->transport.sin); |
78 | srx->transport.family = AF_INET; | |
79 | srx->transport.sin.sin_port = serr->port; | |
80 | memcpy(&srx->transport.sin.sin_addr, | |
75b54cb5 DH |
81 | skb_network_header(skb) + serr->addr_offset, |
82 | sizeof(struct in_addr)); | |
83 | break; | |
84 | default: | |
494337c9 | 85 | memcpy(&srx->transport.sin6.sin6_addr, |
75b54cb5 DH |
86 | &ipv6_hdr(skb)->saddr, |
87 | sizeof(struct in6_addr)); | |
88 | break; | |
89 | } | |
90 | break; | |
d1912747 | 91 | #endif |
75b54cb5 | 92 | |
be6e6707 DH |
93 | default: |
94 | BUG(); | |
95 | } | |
96 | ||
494337c9 | 97 | return rxrpc_lookup_peer_rcu(local, srx); |
be6e6707 DH |
98 | } |
99 | ||
1a70c05b DH |
100 | /* |
101 | * Handle an MTU/fragmentation problem. | |
102 | */ | |
ac56a0b4 | 103 | static void rxrpc_adjust_mtu(struct rxrpc_peer *peer, unsigned int mtu) |
1a70c05b | 104 | { |
1a70c05b | 105 | /* wind down the local interface MTU */ |
e969c92c | 106 | if (mtu > 0 && peer->if_mtu == 65535 && mtu < peer->if_mtu) |
1a70c05b | 107 | peer->if_mtu = mtu; |
1a70c05b DH |
108 | |
109 | if (mtu == 0) { | |
110 | /* they didn't give us a size, estimate one */ | |
111 | mtu = peer->if_mtu; | |
112 | if (mtu > 1500) { | |
113 | mtu >>= 1; | |
114 | if (mtu < 1500) | |
115 | mtu = 1500; | |
116 | } else { | |
117 | mtu -= 100; | |
118 | if (mtu < peer->hdrsize) | |
119 | mtu = peer->hdrsize + 4; | |
120 | } | |
121 | } | |
122 | ||
123 | if (mtu < peer->mtu) { | |
124 | spin_lock_bh(&peer->lock); | |
125 | peer->mtu = mtu; | |
126 | peer->maxdata = peer->mtu - peer->hdrsize; | |
127 | spin_unlock_bh(&peer->lock); | |
1a70c05b DH |
128 | } |
129 | } | |
130 | ||
17926a79 | 131 | /* |
f66d7490 | 132 | * Handle an error received on the local endpoint. |
17926a79 | 133 | */ |
ff734825 | 134 | void rxrpc_input_error(struct rxrpc_local *local, struct sk_buff *skb) |
17926a79 | 135 | { |
ff734825 | 136 | struct sock_exterr_skb *serr = SKB_EXT_ERR(skb); |
494337c9 | 137 | struct sockaddr_rxrpc srx; |
ac56a0b4 | 138 | struct rxrpc_peer *peer = NULL; |
17926a79 | 139 | |
ff734825 | 140 | _enter("L=%x", local->debug_id); |
17926a79 | 141 | |
b6c66c43 DH |
142 | if (!skb->len && serr->ee.ee_origin == SO_EE_ORIGIN_TIMESTAMPING) { |
143 | _leave("UDP empty message"); | |
b6c66c43 DH |
144 | return; |
145 | } | |
494337c9 | 146 | |
ff734825 | 147 | rcu_read_lock(); |
b6c66c43 | 148 | peer = rxrpc_lookup_peer_local_rcu(local, skb, &srx); |
47c810a7 | 149 | if (peer && !rxrpc_get_peer_maybe(peer, rxrpc_peer_get_input_error)) |
b6c66c43 | 150 | peer = NULL; |
ff734825 DH |
151 | rcu_read_unlock(); |
152 | if (!peer) | |
b6c66c43 | 153 | return; |
17926a79 | 154 | |
b6c66c43 DH |
155 | trace_rxrpc_rx_icmp(peer, &serr->ee, &srx); |
156 | ||
157 | if ((serr->ee.ee_origin == SO_EE_ORIGIN_ICMP && | |
158 | serr->ee.ee_type == ICMP_DEST_UNREACH && | |
159 | serr->ee.ee_code == ICMP_FRAG_NEEDED)) { | |
160 | rxrpc_adjust_mtu(peer, serr->ee.ee_info); | |
161 | goto out; | |
162 | } | |
163 | ||
5e6ef4f1 | 164 | rxrpc_store_error(peer, skb); |
b6c66c43 | 165 | out: |
47c810a7 | 166 | rxrpc_put_peer(peer, rxrpc_peer_put_input_error); |
17926a79 DH |
167 | } |
168 | ||
169 | /* | |
f66d7490 | 170 | * Map an error report to error codes on the peer record. |
17926a79 | 171 | */ |
5e6ef4f1 | 172 | static void rxrpc_store_error(struct rxrpc_peer *peer, struct sk_buff *skb) |
17926a79 | 173 | { |
f3344303 | 174 | enum rxrpc_call_completion compl = RXRPC_CALL_NETWORK_ERROR; |
5e6ef4f1 DH |
175 | struct sock_exterr_skb *serr = SKB_EXT_ERR(skb); |
176 | struct sock_extended_err *ee = &serr->ee; | |
177 | int err = ee->ee_errno; | |
17926a79 DH |
178 | |
179 | _enter(""); | |
180 | ||
17926a79 | 181 | switch (ee->ee_origin) { |
f66d7490 | 182 | case SO_EE_ORIGIN_NONE: |
17926a79 | 183 | case SO_EE_ORIGIN_LOCAL: |
f3344303 | 184 | compl = RXRPC_CALL_LOCAL_ERROR; |
17926a79 DH |
185 | break; |
186 | ||
17926a79 | 187 | case SO_EE_ORIGIN_ICMP6: |
23e2db31 DH |
188 | if (err == EACCES) |
189 | err = EHOSTUNREACH; | |
df561f66 | 190 | fallthrough; |
e969c92c | 191 | case SO_EE_ORIGIN_ICMP: |
17926a79 | 192 | default: |
17926a79 DH |
193 | break; |
194 | } | |
195 | ||
5e6ef4f1 | 196 | rxrpc_distribute_error(peer, skb, compl, err); |
f66d7490 DH |
197 | } |
198 | ||
199 | /* | |
f3344303 | 200 | * Distribute an error that occurred on a peer. |
f66d7490 | 201 | */ |
5e6ef4f1 DH |
202 | static void rxrpc_distribute_error(struct rxrpc_peer *peer, struct sk_buff *skb, |
203 | enum rxrpc_call_completion compl, int err) | |
f66d7490 | 204 | { |
f66d7490 | 205 | struct rxrpc_call *call; |
29fb4ec3 DH |
206 | HLIST_HEAD(error_targets); |
207 | ||
208 | spin_lock(&peer->lock); | |
209 | hlist_move_list(&peer->error_targets, &error_targets); | |
210 | ||
211 | while (!hlist_empty(&error_targets)) { | |
212 | call = hlist_entry(error_targets.first, | |
213 | struct rxrpc_call, error_link); | |
214 | hlist_del_init(&call->error_link); | |
215 | spin_unlock(&peer->lock); | |
17926a79 | 216 | |
cb0fc0c9 | 217 | rxrpc_see_call(call, rxrpc_call_see_distribute_error); |
5e6ef4f1 DH |
218 | rxrpc_set_call_completion(call, compl, 0, -err); |
219 | rxrpc_input_call_event(call, skb); | |
29fb4ec3 DH |
220 | |
221 | spin_lock(&peer->lock); | |
17926a79 | 222 | } |
29fb4ec3 DH |
223 | |
224 | spin_unlock(&peer->lock); | |
17926a79 | 225 | } |
cf1a6474 | 226 | |
ace45bec | 227 | /* |
330bdcfa | 228 | * Perform keep-alive pings. |
ace45bec | 229 | */ |
330bdcfa DH |
230 | static void rxrpc_peer_keepalive_dispatch(struct rxrpc_net *rxnet, |
231 | struct list_head *collector, | |
232 | time64_t base, | |
233 | u8 cursor) | |
ace45bec | 234 | { |
ace45bec | 235 | struct rxrpc_peer *peer; |
330bdcfa DH |
236 | const u8 mask = ARRAY_SIZE(rxnet->peer_keepalive) - 1; |
237 | time64_t keepalive_at; | |
238 | int slot; | |
ace45bec | 239 | |
330bdcfa | 240 | spin_lock_bh(&rxnet->peer_hash_lock); |
ace45bec | 241 | |
330bdcfa DH |
242 | while (!list_empty(collector)) { |
243 | peer = list_entry(collector->next, | |
244 | struct rxrpc_peer, keepalive_link); | |
ace45bec | 245 | |
330bdcfa | 246 | list_del_init(&peer->keepalive_link); |
47c810a7 | 247 | if (!rxrpc_get_peer_maybe(peer, rxrpc_peer_get_keepalive)) |
330bdcfa | 248 | continue; |
ace45bec | 249 | |
0fde882f | 250 | if (__rxrpc_use_local(peer->local, rxrpc_local_use_peer_keepalive)) { |
04d36d74 DH |
251 | spin_unlock_bh(&rxnet->peer_hash_lock); |
252 | ||
253 | keepalive_at = peer->last_tx_at + RXRPC_KEEPALIVE_TIME; | |
254 | slot = keepalive_at - base; | |
255 | _debug("%02x peer %u t=%d {%pISp}", | |
256 | cursor, peer->debug_id, slot, &peer->srx.transport); | |
257 | ||
258 | if (keepalive_at <= base || | |
259 | keepalive_at > base + RXRPC_KEEPALIVE_TIME) { | |
260 | rxrpc_send_keepalive(peer); | |
261 | slot = RXRPC_KEEPALIVE_TIME; | |
262 | } | |
330bdcfa | 263 | |
04d36d74 DH |
264 | /* A transmission to this peer occurred since last we |
265 | * examined it so put it into the appropriate future | |
266 | * bucket. | |
267 | */ | |
268 | slot += cursor; | |
269 | slot &= mask; | |
270 | spin_lock_bh(&rxnet->peer_hash_lock); | |
271 | list_add_tail(&peer->keepalive_link, | |
272 | &rxnet->peer_keepalive[slot & mask]); | |
0fde882f | 273 | rxrpc_unuse_local(peer->local, rxrpc_local_unuse_peer_keepalive); |
ace45bec | 274 | } |
47c810a7 | 275 | rxrpc_put_peer_locked(peer, rxrpc_peer_put_keepalive); |
ace45bec DH |
276 | } |
277 | ||
ace45bec | 278 | spin_unlock_bh(&rxnet->peer_hash_lock); |
330bdcfa | 279 | } |
ace45bec | 280 | |
330bdcfa DH |
281 | /* |
282 | * Perform keep-alive pings with VERSION packets to keep any NAT alive. | |
283 | */ | |
284 | void rxrpc_peer_keepalive_worker(struct work_struct *work) | |
285 | { | |
286 | struct rxrpc_net *rxnet = | |
287 | container_of(work, struct rxrpc_net, peer_keepalive_work); | |
288 | const u8 mask = ARRAY_SIZE(rxnet->peer_keepalive) - 1; | |
289 | time64_t base, now, delay; | |
290 | u8 cursor, stop; | |
291 | LIST_HEAD(collector); | |
ace45bec | 292 | |
330bdcfa DH |
293 | now = ktime_get_seconds(); |
294 | base = rxnet->peer_keepalive_base; | |
295 | cursor = rxnet->peer_keepalive_cursor; | |
296 | _enter("%lld,%u", base - now, cursor); | |
ace45bec | 297 | |
330bdcfa DH |
298 | if (!rxnet->live) |
299 | return; | |
ace45bec | 300 | |
330bdcfa DH |
301 | /* Remove to a temporary list all the peers that are currently lodged |
302 | * in expired buckets plus all new peers. | |
303 | * | |
304 | * Everything in the bucket at the cursor is processed this | |
305 | * second; the bucket at cursor + 1 goes at now + 1s and so | |
306 | * on... | |
ace45bec | 307 | */ |
ace45bec | 308 | spin_lock_bh(&rxnet->peer_hash_lock); |
330bdcfa DH |
309 | list_splice_init(&rxnet->peer_keepalive_new, &collector); |
310 | ||
311 | stop = cursor + ARRAY_SIZE(rxnet->peer_keepalive); | |
312 | while (base <= now && (s8)(cursor - stop) < 0) { | |
313 | list_splice_tail_init(&rxnet->peer_keepalive[cursor & mask], | |
314 | &collector); | |
315 | base++; | |
316 | cursor++; | |
317 | } | |
ace45bec | 318 | |
330bdcfa DH |
319 | base = now; |
320 | spin_unlock_bh(&rxnet->peer_hash_lock); | |
ace45bec | 321 | |
ace45bec DH |
322 | rxnet->peer_keepalive_base = base; |
323 | rxnet->peer_keepalive_cursor = cursor; | |
330bdcfa DH |
324 | rxrpc_peer_keepalive_dispatch(rxnet, &collector, base, cursor); |
325 | ASSERT(list_empty(&collector)); | |
326 | ||
327 | /* Schedule the timer for the next occupied timeslot. */ | |
328 | cursor = rxnet->peer_keepalive_cursor; | |
329 | stop = cursor + RXRPC_KEEPALIVE_TIME - 1; | |
330 | for (; (s8)(cursor - stop) < 0; cursor++) { | |
331 | if (!list_empty(&rxnet->peer_keepalive[cursor & mask])) | |
332 | break; | |
333 | base++; | |
334 | } | |
335 | ||
336 | now = ktime_get_seconds(); | |
337 | delay = base - now; | |
338 | if (delay < 1) | |
339 | delay = 1; | |
340 | delay *= HZ; | |
341 | if (rxnet->live) | |
342 | timer_reduce(&rxnet->peer_keepalive_timer, jiffies + delay); | |
343 | ||
ace45bec DH |
344 | _leave(""); |
345 | } |