1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* Peer event handling, typically ICMP messages. 3 * 4 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved. 5 * Written by David Howells (dhowells@redhat.com) 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 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); 24 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 41 /* Can we see an ICMP4 packet on an ICMP6 listening socket? and vice 42 * versa? 43 */ 44 switch (srx->transport.family) { 45 case AF_INET: 46 srx->transport_len = sizeof(srx->transport.sin); 47 srx->transport.family = AF_INET; 48 srx->transport.sin.sin_port = serr->port; 49 switch (serr->ee.ee_origin) { 50 case SO_EE_ORIGIN_ICMP: 51 memcpy(&srx->transport.sin.sin_addr, 52 skb_network_header(skb) + serr->addr_offset, 53 sizeof(struct in_addr)); 54 break; 55 case SO_EE_ORIGIN_ICMP6: 56 memcpy(&srx->transport.sin.sin_addr, 57 skb_network_header(skb) + serr->addr_offset + 12, 58 sizeof(struct in_addr)); 59 break; 60 default: 61 memcpy(&srx->transport.sin.sin_addr, &ip_hdr(skb)->saddr, 62 sizeof(struct in_addr)); 63 break; 64 } 65 break; 66 67 #ifdef CONFIG_AF_RXRPC_IPV6 68 case AF_INET6: 69 switch (serr->ee.ee_origin) { 70 case SO_EE_ORIGIN_ICMP6: 71 srx->transport.sin6.sin6_port = serr->port; 72 memcpy(&srx->transport.sin6.sin6_addr, 73 skb_network_header(skb) + serr->addr_offset, 74 sizeof(struct in6_addr)); 75 break; 76 case SO_EE_ORIGIN_ICMP: 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, 81 skb_network_header(skb) + serr->addr_offset, 82 sizeof(struct in_addr)); 83 break; 84 default: 85 memcpy(&srx->transport.sin6.sin6_addr, 86 &ipv6_hdr(skb)->saddr, 87 sizeof(struct in6_addr)); 88 break; 89 } 90 break; 91 #endif 92 93 default: 94 BUG(); 95 } 96 97 return rxrpc_lookup_peer_rcu(local, srx); 98 } 99 100 /* 101 * Handle an MTU/fragmentation problem. 102 */ 103 static void rxrpc_adjust_mtu(struct rxrpc_peer *peer, unsigned int mtu) 104 { 105 /* wind down the local interface MTU */ 106 if (mtu > 0 && peer->if_mtu == 65535 && mtu < peer->if_mtu) 107 peer->if_mtu = mtu; 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(&peer->lock); 125 peer->mtu = mtu; 126 peer->maxdata = peer->mtu - peer->hdrsize; 127 spin_unlock(&peer->lock); 128 } 129 } 130 131 /* 132 * Handle an error received on the local endpoint. 133 */ 134 void rxrpc_input_error(struct rxrpc_local *local, struct sk_buff *skb) 135 { 136 struct sock_exterr_skb *serr = SKB_EXT_ERR(skb); 137 struct sockaddr_rxrpc srx; 138 struct rxrpc_peer *peer = NULL; 139 140 _enter("L=%x", local->debug_id); 141 142 if (!skb->len && serr->ee.ee_origin == SO_EE_ORIGIN_TIMESTAMPING) { 143 _leave("UDP empty message"); 144 return; 145 } 146 147 rcu_read_lock(); 148 peer = rxrpc_lookup_peer_local_rcu(local, skb, &srx); 149 if (peer && !rxrpc_get_peer_maybe(peer, rxrpc_peer_get_input_error)) 150 peer = NULL; 151 rcu_read_unlock(); 152 if (!peer) 153 return; 154 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, skb); 165 out: 166 rxrpc_put_peer(peer, rxrpc_peer_put_input_error); 167 } 168 169 /* 170 * Map an error report to error codes on the peer record. 171 */ 172 static void rxrpc_store_error(struct rxrpc_peer *peer, struct sk_buff *skb) 173 { 174 enum rxrpc_call_completion compl = RXRPC_CALL_NETWORK_ERROR; 175 struct sock_exterr_skb *serr = SKB_EXT_ERR(skb); 176 struct sock_extended_err *ee = &serr->ee; 177 int err = ee->ee_errno; 178 179 _enter(""); 180 181 switch (ee->ee_origin) { 182 case SO_EE_ORIGIN_NONE: 183 case SO_EE_ORIGIN_LOCAL: 184 compl = RXRPC_CALL_LOCAL_ERROR; 185 break; 186 187 case SO_EE_ORIGIN_ICMP6: 188 if (err == EACCES) 189 err = EHOSTUNREACH; 190 fallthrough; 191 case SO_EE_ORIGIN_ICMP: 192 default: 193 break; 194 } 195 196 rxrpc_distribute_error(peer, skb, compl, err); 197 } 198 199 /* 200 * Distribute an error that occurred on a peer. 201 */ 202 static void rxrpc_distribute_error(struct rxrpc_peer *peer, struct sk_buff *skb, 203 enum rxrpc_call_completion compl, int err) 204 { 205 struct rxrpc_call *call; 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); 216 217 rxrpc_see_call(call, rxrpc_call_see_distribute_error); 218 rxrpc_set_call_completion(call, compl, 0, -err); 219 rxrpc_input_call_event(call, skb); 220 221 spin_lock(&peer->lock); 222 } 223 224 spin_unlock(&peer->lock); 225 } 226 227 /* 228 * Perform keep-alive pings. 229 */ 230 static void rxrpc_peer_keepalive_dispatch(struct rxrpc_net *rxnet, 231 struct list_head *collector, 232 time64_t base, 233 u8 cursor) 234 { 235 struct rxrpc_peer *peer; 236 const u8 mask = ARRAY_SIZE(rxnet->peer_keepalive) - 1; 237 time64_t keepalive_at; 238 int slot; 239 240 spin_lock(&rxnet->peer_hash_lock); 241 242 while (!list_empty(collector)) { 243 peer = list_entry(collector->next, 244 struct rxrpc_peer, keepalive_link); 245 246 list_del_init(&peer->keepalive_link); 247 if (!rxrpc_get_peer_maybe(peer, rxrpc_peer_get_keepalive)) 248 continue; 249 250 if (__rxrpc_use_local(peer->local, rxrpc_local_use_peer_keepalive)) { 251 spin_unlock(&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 } 263 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(&rxnet->peer_hash_lock); 271 list_add_tail(&peer->keepalive_link, 272 &rxnet->peer_keepalive[slot & mask]); 273 rxrpc_unuse_local(peer->local, rxrpc_local_unuse_peer_keepalive); 274 } 275 rxrpc_put_peer_locked(peer, rxrpc_peer_put_keepalive); 276 } 277 278 spin_unlock(&rxnet->peer_hash_lock); 279 } 280 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); 292 293 now = ktime_get_seconds(); 294 base = rxnet->peer_keepalive_base; 295 cursor = rxnet->peer_keepalive_cursor; 296 _enter("%lld,%u", base - now, cursor); 297 298 if (!rxnet->live) 299 return; 300 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... 307 */ 308 spin_lock(&rxnet->peer_hash_lock); 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 } 318 319 base = now; 320 spin_unlock(&rxnet->peer_hash_lock); 321 322 rxnet->peer_keepalive_base = base; 323 rxnet->peer_keepalive_cursor = cursor; 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 344 _leave(""); 345 } 346