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 | ||
f66d7490 | 21 | static void rxrpc_store_error(struct rxrpc_peer *, struct sock_exterr_skb *); |
f3344303 DH |
22 | static void rxrpc_distribute_error(struct rxrpc_peer *, int, |
23 | enum rxrpc_call_completion); | |
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 | ||
164 | rxrpc_store_error(peer, serr); | |
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 | */ |
f66d7490 DH |
172 | static void rxrpc_store_error(struct rxrpc_peer *peer, |
173 | struct sock_exterr_skb *serr) | |
17926a79 | 174 | { |
f3344303 | 175 | enum rxrpc_call_completion compl = RXRPC_CALL_NETWORK_ERROR; |
17926a79 | 176 | struct sock_extended_err *ee; |
c9d10c49 | 177 | int err; |
17926a79 DH |
178 | |
179 | _enter(""); | |
180 | ||
17926a79 DH |
181 | ee = &serr->ee; |
182 | ||
17926a79 DH |
183 | err = ee->ee_errno; |
184 | ||
185 | switch (ee->ee_origin) { | |
f66d7490 | 186 | case SO_EE_ORIGIN_NONE: |
17926a79 | 187 | case SO_EE_ORIGIN_LOCAL: |
f3344303 | 188 | compl = RXRPC_CALL_LOCAL_ERROR; |
17926a79 DH |
189 | break; |
190 | ||
17926a79 | 191 | case SO_EE_ORIGIN_ICMP6: |
23e2db31 DH |
192 | if (err == EACCES) |
193 | err = EHOSTUNREACH; | |
df561f66 | 194 | fallthrough; |
e969c92c | 195 | case SO_EE_ORIGIN_ICMP: |
17926a79 | 196 | default: |
17926a79 DH |
197 | break; |
198 | } | |
199 | ||
f3344303 | 200 | rxrpc_distribute_error(peer, err, compl); |
f66d7490 DH |
201 | } |
202 | ||
203 | /* | |
f3344303 | 204 | * Distribute an error that occurred on a peer. |
f66d7490 | 205 | */ |
f3344303 DH |
206 | static void rxrpc_distribute_error(struct rxrpc_peer *peer, int error, |
207 | enum rxrpc_call_completion compl) | |
f66d7490 | 208 | { |
f66d7490 | 209 | struct rxrpc_call *call; |
29fb4ec3 DH |
210 | HLIST_HEAD(error_targets); |
211 | ||
212 | spin_lock(&peer->lock); | |
213 | hlist_move_list(&peer->error_targets, &error_targets); | |
214 | ||
215 | while (!hlist_empty(&error_targets)) { | |
216 | call = hlist_entry(error_targets.first, | |
217 | struct rxrpc_call, error_link); | |
218 | hlist_del_init(&call->error_link); | |
219 | spin_unlock(&peer->lock); | |
17926a79 | 220 | |
cb0fc0c9 | 221 | rxrpc_see_call(call, rxrpc_call_see_distribute_error); |
5ac0d622 | 222 | rxrpc_set_call_completion(call, compl, 0, -error); |
29fb4ec3 DH |
223 | |
224 | spin_lock(&peer->lock); | |
17926a79 | 225 | } |
29fb4ec3 DH |
226 | |
227 | spin_unlock(&peer->lock); | |
17926a79 | 228 | } |
cf1a6474 | 229 | |
ace45bec | 230 | /* |
330bdcfa | 231 | * Perform keep-alive pings. |
ace45bec | 232 | */ |
330bdcfa DH |
233 | static void rxrpc_peer_keepalive_dispatch(struct rxrpc_net *rxnet, |
234 | struct list_head *collector, | |
235 | time64_t base, | |
236 | u8 cursor) | |
ace45bec | 237 | { |
ace45bec | 238 | struct rxrpc_peer *peer; |
330bdcfa DH |
239 | const u8 mask = ARRAY_SIZE(rxnet->peer_keepalive) - 1; |
240 | time64_t keepalive_at; | |
241 | int slot; | |
ace45bec | 242 | |
330bdcfa | 243 | spin_lock_bh(&rxnet->peer_hash_lock); |
ace45bec | 244 | |
330bdcfa DH |
245 | while (!list_empty(collector)) { |
246 | peer = list_entry(collector->next, | |
247 | struct rxrpc_peer, keepalive_link); | |
ace45bec | 248 | |
330bdcfa | 249 | list_del_init(&peer->keepalive_link); |
47c810a7 | 250 | if (!rxrpc_get_peer_maybe(peer, rxrpc_peer_get_keepalive)) |
330bdcfa | 251 | continue; |
ace45bec | 252 | |
0fde882f | 253 | if (__rxrpc_use_local(peer->local, rxrpc_local_use_peer_keepalive)) { |
04d36d74 DH |
254 | spin_unlock_bh(&rxnet->peer_hash_lock); |
255 | ||
256 | keepalive_at = peer->last_tx_at + RXRPC_KEEPALIVE_TIME; | |
257 | slot = keepalive_at - base; | |
258 | _debug("%02x peer %u t=%d {%pISp}", | |
259 | cursor, peer->debug_id, slot, &peer->srx.transport); | |
260 | ||
261 | if (keepalive_at <= base || | |
262 | keepalive_at > base + RXRPC_KEEPALIVE_TIME) { | |
263 | rxrpc_send_keepalive(peer); | |
264 | slot = RXRPC_KEEPALIVE_TIME; | |
265 | } | |
330bdcfa | 266 | |
04d36d74 DH |
267 | /* A transmission to this peer occurred since last we |
268 | * examined it so put it into the appropriate future | |
269 | * bucket. | |
270 | */ | |
271 | slot += cursor; | |
272 | slot &= mask; | |
273 | spin_lock_bh(&rxnet->peer_hash_lock); | |
274 | list_add_tail(&peer->keepalive_link, | |
275 | &rxnet->peer_keepalive[slot & mask]); | |
0fde882f | 276 | rxrpc_unuse_local(peer->local, rxrpc_local_unuse_peer_keepalive); |
ace45bec | 277 | } |
47c810a7 | 278 | rxrpc_put_peer_locked(peer, rxrpc_peer_put_keepalive); |
ace45bec DH |
279 | } |
280 | ||
ace45bec | 281 | spin_unlock_bh(&rxnet->peer_hash_lock); |
330bdcfa | 282 | } |
ace45bec | 283 | |
330bdcfa DH |
284 | /* |
285 | * Perform keep-alive pings with VERSION packets to keep any NAT alive. | |
286 | */ | |
287 | void rxrpc_peer_keepalive_worker(struct work_struct *work) | |
288 | { | |
289 | struct rxrpc_net *rxnet = | |
290 | container_of(work, struct rxrpc_net, peer_keepalive_work); | |
291 | const u8 mask = ARRAY_SIZE(rxnet->peer_keepalive) - 1; | |
292 | time64_t base, now, delay; | |
293 | u8 cursor, stop; | |
294 | LIST_HEAD(collector); | |
ace45bec | 295 | |
330bdcfa DH |
296 | now = ktime_get_seconds(); |
297 | base = rxnet->peer_keepalive_base; | |
298 | cursor = rxnet->peer_keepalive_cursor; | |
299 | _enter("%lld,%u", base - now, cursor); | |
ace45bec | 300 | |
330bdcfa DH |
301 | if (!rxnet->live) |
302 | return; | |
ace45bec | 303 | |
330bdcfa DH |
304 | /* Remove to a temporary list all the peers that are currently lodged |
305 | * in expired buckets plus all new peers. | |
306 | * | |
307 | * Everything in the bucket at the cursor is processed this | |
308 | * second; the bucket at cursor + 1 goes at now + 1s and so | |
309 | * on... | |
ace45bec | 310 | */ |
ace45bec | 311 | spin_lock_bh(&rxnet->peer_hash_lock); |
330bdcfa DH |
312 | list_splice_init(&rxnet->peer_keepalive_new, &collector); |
313 | ||
314 | stop = cursor + ARRAY_SIZE(rxnet->peer_keepalive); | |
315 | while (base <= now && (s8)(cursor - stop) < 0) { | |
316 | list_splice_tail_init(&rxnet->peer_keepalive[cursor & mask], | |
317 | &collector); | |
318 | base++; | |
319 | cursor++; | |
320 | } | |
ace45bec | 321 | |
330bdcfa DH |
322 | base = now; |
323 | spin_unlock_bh(&rxnet->peer_hash_lock); | |
ace45bec | 324 | |
ace45bec DH |
325 | rxnet->peer_keepalive_base = base; |
326 | rxnet->peer_keepalive_cursor = cursor; | |
330bdcfa DH |
327 | rxrpc_peer_keepalive_dispatch(rxnet, &collector, base, cursor); |
328 | ASSERT(list_empty(&collector)); | |
329 | ||
330 | /* Schedule the timer for the next occupied timeslot. */ | |
331 | cursor = rxnet->peer_keepalive_cursor; | |
332 | stop = cursor + RXRPC_KEEPALIVE_TIME - 1; | |
333 | for (; (s8)(cursor - stop) < 0; cursor++) { | |
334 | if (!list_empty(&rxnet->peer_keepalive[cursor & mask])) | |
335 | break; | |
336 | base++; | |
337 | } | |
338 | ||
339 | now = ktime_get_seconds(); | |
340 | delay = base - now; | |
341 | if (delay < 1) | |
342 | delay = 1; | |
343 | delay *= HZ; | |
344 | if (rxnet->live) | |
345 | timer_reduce(&rxnet->peer_keepalive_timer, jiffies + delay); | |
346 | ||
ace45bec DH |
347 | _leave(""); |
348 | } |