Commit | Line | Data |
---|---|---|
17926a79 DH |
1 | /* Error message handling (ICMP) |
2 | * | |
3 | * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved. | |
4 | * Written by David Howells (dhowells@redhat.com) | |
5 | * | |
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. | |
10 | */ | |
11 | ||
12 | #include <linux/module.h> | |
13 | #include <linux/net.h> | |
14 | #include <linux/skbuff.h> | |
15 | #include <linux/errqueue.h> | |
16 | #include <linux/udp.h> | |
17 | #include <linux/in.h> | |
18 | #include <linux/in6.h> | |
19 | #include <linux/icmp.h> | |
20 | #include <net/sock.h> | |
21 | #include <net/af_rxrpc.h> | |
22 | #include <net/ip.h> | |
23 | #include "ar-internal.h" | |
24 | ||
25 | /* | |
26 | * handle an error received on the local endpoint | |
27 | */ | |
28 | void rxrpc_UDP_error_report(struct sock *sk) | |
29 | { | |
30 | struct sock_exterr_skb *serr; | |
31 | struct rxrpc_transport *trans; | |
32 | struct rxrpc_local *local = sk->sk_user_data; | |
33 | struct rxrpc_peer *peer; | |
34 | struct sk_buff *skb; | |
35 | __be32 addr; | |
36 | __be16 port; | |
37 | ||
38 | _enter("%p{%d}", sk, local->debug_id); | |
39 | ||
40 | skb = skb_dequeue(&sk->sk_error_queue); | |
41 | if (!skb) { | |
42 | _leave("UDP socket errqueue empty"); | |
43 | return; | |
44 | } | |
45 | ||
46 | rxrpc_new_skb(skb); | |
47 | ||
48 | serr = SKB_EXT_ERR(skb); | |
49 | addr = *(__be32 *)(skb_network_header(skb) + serr->addr_offset); | |
50 | port = serr->port; | |
51 | ||
52 | _net("Rx UDP Error from "NIPQUAD_FMT":%hu", | |
53 | NIPQUAD(addr), ntohs(port)); | |
54 | _debug("Msg l:%d d:%d", skb->len, skb->data_len); | |
55 | ||
56 | peer = rxrpc_find_peer(local, addr, port); | |
57 | if (IS_ERR(peer)) { | |
58 | rxrpc_free_skb(skb); | |
59 | _leave(" [no peer]"); | |
60 | return; | |
61 | } | |
62 | ||
63 | trans = rxrpc_find_transport(local, peer); | |
64 | if (!trans) { | |
65 | rxrpc_put_peer(peer); | |
66 | rxrpc_free_skb(skb); | |
67 | _leave(" [no trans]"); | |
68 | return; | |
69 | } | |
70 | ||
71 | if (serr->ee.ee_origin == SO_EE_ORIGIN_ICMP && | |
72 | serr->ee.ee_type == ICMP_DEST_UNREACH && | |
73 | serr->ee.ee_code == ICMP_FRAG_NEEDED | |
74 | ) { | |
75 | u32 mtu = serr->ee.ee_info; | |
76 | ||
77 | _net("Rx Received ICMP Fragmentation Needed (%d)", mtu); | |
78 | ||
79 | /* wind down the local interface MTU */ | |
80 | if (mtu > 0 && peer->if_mtu == 65535 && mtu < peer->if_mtu) { | |
81 | peer->if_mtu = mtu; | |
82 | _net("I/F MTU %u", mtu); | |
83 | } | |
84 | ||
85 | /* ip_rt_frag_needed() may have eaten the info */ | |
86 | if (mtu == 0) | |
87 | mtu = ntohs(icmp_hdr(skb)->un.frag.mtu); | |
88 | ||
89 | if (mtu == 0) { | |
90 | /* they didn't give us a size, estimate one */ | |
91 | if (mtu > 1500) { | |
92 | mtu >>= 1; | |
93 | if (mtu < 1500) | |
94 | mtu = 1500; | |
95 | } else { | |
96 | mtu -= 100; | |
97 | if (mtu < peer->hdrsize) | |
98 | mtu = peer->hdrsize + 4; | |
99 | } | |
100 | } | |
101 | ||
102 | if (mtu < peer->mtu) { | |
224711df | 103 | spin_lock_bh(&peer->lock); |
17926a79 DH |
104 | peer->mtu = mtu; |
105 | peer->maxdata = peer->mtu - peer->hdrsize; | |
224711df | 106 | spin_unlock_bh(&peer->lock); |
17926a79 DH |
107 | _net("Net MTU %u (maxdata %u)", |
108 | peer->mtu, peer->maxdata); | |
109 | } | |
110 | } | |
111 | ||
112 | rxrpc_put_peer(peer); | |
113 | ||
114 | /* pass the transport ref to error_handler to release */ | |
115 | skb_queue_tail(&trans->error_queue, skb); | |
651350d1 | 116 | rxrpc_queue_work(&trans->error_handler); |
17926a79 DH |
117 | |
118 | /* reset and regenerate socket error */ | |
119 | spin_lock_bh(&sk->sk_error_queue.lock); | |
120 | sk->sk_err = 0; | |
121 | skb = skb_peek(&sk->sk_error_queue); | |
122 | if (skb) { | |
123 | sk->sk_err = SKB_EXT_ERR(skb)->ee.ee_errno; | |
124 | spin_unlock_bh(&sk->sk_error_queue.lock); | |
125 | sk->sk_error_report(sk); | |
126 | } else { | |
127 | spin_unlock_bh(&sk->sk_error_queue.lock); | |
128 | } | |
129 | ||
130 | _leave(""); | |
131 | } | |
132 | ||
133 | /* | |
134 | * deal with UDP error messages | |
135 | */ | |
136 | void rxrpc_UDP_error_handler(struct work_struct *work) | |
137 | { | |
138 | struct sock_extended_err *ee; | |
139 | struct sock_exterr_skb *serr; | |
140 | struct rxrpc_transport *trans = | |
141 | container_of(work, struct rxrpc_transport, error_handler); | |
142 | struct sk_buff *skb; | |
143 | int local, err; | |
144 | ||
145 | _enter(""); | |
146 | ||
147 | skb = skb_dequeue(&trans->error_queue); | |
148 | if (!skb) | |
149 | return; | |
150 | ||
151 | serr = SKB_EXT_ERR(skb); | |
152 | ee = &serr->ee; | |
153 | ||
154 | _net("Rx Error o=%d t=%d c=%d e=%d", | |
155 | ee->ee_origin, ee->ee_type, ee->ee_code, ee->ee_errno); | |
156 | ||
157 | err = ee->ee_errno; | |
158 | ||
159 | switch (ee->ee_origin) { | |
160 | case SO_EE_ORIGIN_ICMP: | |
161 | local = 0; | |
162 | switch (ee->ee_type) { | |
163 | case ICMP_DEST_UNREACH: | |
164 | switch (ee->ee_code) { | |
165 | case ICMP_NET_UNREACH: | |
166 | _net("Rx Received ICMP Network Unreachable"); | |
167 | err = ENETUNREACH; | |
168 | break; | |
169 | case ICMP_HOST_UNREACH: | |
170 | _net("Rx Received ICMP Host Unreachable"); | |
171 | err = EHOSTUNREACH; | |
172 | break; | |
173 | case ICMP_PORT_UNREACH: | |
174 | _net("Rx Received ICMP Port Unreachable"); | |
175 | err = ECONNREFUSED; | |
176 | break; | |
177 | case ICMP_FRAG_NEEDED: | |
178 | _net("Rx Received ICMP Fragmentation Needed (%d)", | |
179 | ee->ee_info); | |
180 | err = 0; /* dealt with elsewhere */ | |
181 | break; | |
182 | case ICMP_NET_UNKNOWN: | |
183 | _net("Rx Received ICMP Unknown Network"); | |
184 | err = ENETUNREACH; | |
185 | break; | |
186 | case ICMP_HOST_UNKNOWN: | |
187 | _net("Rx Received ICMP Unknown Host"); | |
188 | err = EHOSTUNREACH; | |
189 | break; | |
190 | default: | |
191 | _net("Rx Received ICMP DestUnreach code=%u", | |
192 | ee->ee_code); | |
193 | break; | |
194 | } | |
195 | break; | |
196 | ||
197 | case ICMP_TIME_EXCEEDED: | |
198 | _net("Rx Received ICMP TTL Exceeded"); | |
199 | break; | |
200 | ||
201 | default: | |
202 | _proto("Rx Received ICMP error { type=%u code=%u }", | |
203 | ee->ee_type, ee->ee_code); | |
204 | break; | |
205 | } | |
206 | break; | |
207 | ||
208 | case SO_EE_ORIGIN_LOCAL: | |
209 | _proto("Rx Received local error { error=%d }", | |
210 | ee->ee_errno); | |
211 | local = 1; | |
212 | break; | |
213 | ||
214 | case SO_EE_ORIGIN_NONE: | |
215 | case SO_EE_ORIGIN_ICMP6: | |
216 | default: | |
217 | _proto("Rx Received error report { orig=%u }", | |
218 | ee->ee_origin); | |
219 | local = 0; | |
220 | break; | |
221 | } | |
222 | ||
223 | /* terminate all the affected calls if there's an unrecoverable | |
224 | * error */ | |
225 | if (err) { | |
226 | struct rxrpc_call *call, *_n; | |
227 | ||
228 | _debug("ISSUE ERROR %d", err); | |
229 | ||
230 | spin_lock_bh(&trans->peer->lock); | |
231 | trans->peer->net_error = err; | |
232 | ||
233 | list_for_each_entry_safe(call, _n, &trans->peer->error_targets, | |
234 | error_link) { | |
235 | write_lock(&call->state_lock); | |
236 | if (call->state != RXRPC_CALL_COMPLETE && | |
237 | call->state < RXRPC_CALL_NETWORK_ERROR) { | |
238 | call->state = RXRPC_CALL_NETWORK_ERROR; | |
239 | set_bit(RXRPC_CALL_RCVD_ERROR, &call->events); | |
651350d1 | 240 | rxrpc_queue_call(call); |
17926a79 DH |
241 | } |
242 | write_unlock(&call->state_lock); | |
243 | list_del_init(&call->error_link); | |
244 | } | |
245 | ||
246 | spin_unlock_bh(&trans->peer->lock); | |
247 | } | |
248 | ||
249 | if (!skb_queue_empty(&trans->error_queue)) | |
651350d1 | 250 | rxrpc_queue_work(&trans->error_handler); |
17926a79 DH |
251 | |
252 | rxrpc_free_skb(skb); | |
253 | rxrpc_put_transport(trans); | |
254 | _leave(""); | |
255 | } |