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 | ||
364a9e93 | 40 | skb = sock_dequeue_err_skb(sk); |
17926a79 DH |
41 | if (!skb) { |
42 | _leave("UDP socket errqueue empty"); | |
43 | return; | |
44 | } | |
c247f053 WB |
45 | serr = SKB_EXT_ERR(skb); |
46 | if (!skb->len && serr->ee.ee_origin == SO_EE_ORIGIN_TIMESTAMPING) { | |
49ca0d8b WB |
47 | _leave("UDP empty message"); |
48 | kfree_skb(skb); | |
49 | return; | |
50 | } | |
17926a79 DH |
51 | |
52 | rxrpc_new_skb(skb); | |
53 | ||
17926a79 DH |
54 | addr = *(__be32 *)(skb_network_header(skb) + serr->addr_offset); |
55 | port = serr->port; | |
56 | ||
21454aaa | 57 | _net("Rx UDP Error from %pI4:%hu", &addr, ntohs(port)); |
17926a79 DH |
58 | _debug("Msg l:%d d:%d", skb->len, skb->data_len); |
59 | ||
60 | peer = rxrpc_find_peer(local, addr, port); | |
61 | if (IS_ERR(peer)) { | |
62 | rxrpc_free_skb(skb); | |
63 | _leave(" [no peer]"); | |
64 | return; | |
65 | } | |
66 | ||
67 | trans = rxrpc_find_transport(local, peer); | |
68 | if (!trans) { | |
69 | rxrpc_put_peer(peer); | |
70 | rxrpc_free_skb(skb); | |
71 | _leave(" [no trans]"); | |
72 | return; | |
73 | } | |
74 | ||
75 | if (serr->ee.ee_origin == SO_EE_ORIGIN_ICMP && | |
76 | serr->ee.ee_type == ICMP_DEST_UNREACH && | |
77 | serr->ee.ee_code == ICMP_FRAG_NEEDED | |
78 | ) { | |
79 | u32 mtu = serr->ee.ee_info; | |
80 | ||
81 | _net("Rx Received ICMP Fragmentation Needed (%d)", mtu); | |
82 | ||
83 | /* wind down the local interface MTU */ | |
84 | if (mtu > 0 && peer->if_mtu == 65535 && mtu < peer->if_mtu) { | |
85 | peer->if_mtu = mtu; | |
86 | _net("I/F MTU %u", mtu); | |
87 | } | |
88 | ||
17926a79 DH |
89 | if (mtu == 0) { |
90 | /* they didn't give us a size, estimate one */ | |
6c9a2d32 | 91 | mtu = peer->if_mtu; |
17926a79 DH |
92 | if (mtu > 1500) { |
93 | mtu >>= 1; | |
94 | if (mtu < 1500) | |
95 | mtu = 1500; | |
96 | } else { | |
97 | mtu -= 100; | |
98 | if (mtu < peer->hdrsize) | |
99 | mtu = peer->hdrsize + 4; | |
100 | } | |
101 | } | |
102 | ||
103 | if (mtu < peer->mtu) { | |
224711df | 104 | spin_lock_bh(&peer->lock); |
17926a79 DH |
105 | peer->mtu = mtu; |
106 | peer->maxdata = peer->mtu - peer->hdrsize; | |
224711df | 107 | spin_unlock_bh(&peer->lock); |
17926a79 DH |
108 | _net("Net MTU %u (maxdata %u)", |
109 | peer->mtu, peer->maxdata); | |
110 | } | |
111 | } | |
112 | ||
113 | rxrpc_put_peer(peer); | |
114 | ||
115 | /* pass the transport ref to error_handler to release */ | |
116 | skb_queue_tail(&trans->error_queue, skb); | |
651350d1 | 117 | rxrpc_queue_work(&trans->error_handler); |
17926a79 DH |
118 | _leave(""); |
119 | } | |
120 | ||
121 | /* | |
122 | * deal with UDP error messages | |
123 | */ | |
124 | void rxrpc_UDP_error_handler(struct work_struct *work) | |
125 | { | |
126 | struct sock_extended_err *ee; | |
127 | struct sock_exterr_skb *serr; | |
128 | struct rxrpc_transport *trans = | |
129 | container_of(work, struct rxrpc_transport, error_handler); | |
130 | struct sk_buff *skb; | |
c9d10c49 | 131 | int err; |
17926a79 DH |
132 | |
133 | _enter(""); | |
134 | ||
135 | skb = skb_dequeue(&trans->error_queue); | |
136 | if (!skb) | |
137 | return; | |
138 | ||
139 | serr = SKB_EXT_ERR(skb); | |
140 | ee = &serr->ee; | |
141 | ||
142 | _net("Rx Error o=%d t=%d c=%d e=%d", | |
143 | ee->ee_origin, ee->ee_type, ee->ee_code, ee->ee_errno); | |
144 | ||
145 | err = ee->ee_errno; | |
146 | ||
147 | switch (ee->ee_origin) { | |
148 | case SO_EE_ORIGIN_ICMP: | |
17926a79 DH |
149 | switch (ee->ee_type) { |
150 | case ICMP_DEST_UNREACH: | |
151 | switch (ee->ee_code) { | |
152 | case ICMP_NET_UNREACH: | |
153 | _net("Rx Received ICMP Network Unreachable"); | |
17926a79 DH |
154 | break; |
155 | case ICMP_HOST_UNREACH: | |
156 | _net("Rx Received ICMP Host Unreachable"); | |
17926a79 DH |
157 | break; |
158 | case ICMP_PORT_UNREACH: | |
159 | _net("Rx Received ICMP Port Unreachable"); | |
17926a79 DH |
160 | break; |
161 | case ICMP_NET_UNKNOWN: | |
162 | _net("Rx Received ICMP Unknown Network"); | |
17926a79 DH |
163 | break; |
164 | case ICMP_HOST_UNKNOWN: | |
165 | _net("Rx Received ICMP Unknown Host"); | |
17926a79 DH |
166 | break; |
167 | default: | |
168 | _net("Rx Received ICMP DestUnreach code=%u", | |
169 | ee->ee_code); | |
170 | break; | |
171 | } | |
172 | break; | |
173 | ||
174 | case ICMP_TIME_EXCEEDED: | |
175 | _net("Rx Received ICMP TTL Exceeded"); | |
176 | break; | |
177 | ||
178 | default: | |
179 | _proto("Rx Received ICMP error { type=%u code=%u }", | |
180 | ee->ee_type, ee->ee_code); | |
181 | break; | |
182 | } | |
183 | break; | |
184 | ||
185 | case SO_EE_ORIGIN_LOCAL: | |
186 | _proto("Rx Received local error { error=%d }", | |
187 | ee->ee_errno); | |
17926a79 DH |
188 | break; |
189 | ||
190 | case SO_EE_ORIGIN_NONE: | |
191 | case SO_EE_ORIGIN_ICMP6: | |
192 | default: | |
193 | _proto("Rx Received error report { orig=%u }", | |
194 | ee->ee_origin); | |
17926a79 DH |
195 | break; |
196 | } | |
197 | ||
198 | /* terminate all the affected calls if there's an unrecoverable | |
199 | * error */ | |
200 | if (err) { | |
201 | struct rxrpc_call *call, *_n; | |
202 | ||
203 | _debug("ISSUE ERROR %d", err); | |
204 | ||
205 | spin_lock_bh(&trans->peer->lock); | |
206 | trans->peer->net_error = err; | |
207 | ||
208 | list_for_each_entry_safe(call, _n, &trans->peer->error_targets, | |
209 | error_link) { | |
210 | write_lock(&call->state_lock); | |
211 | if (call->state != RXRPC_CALL_COMPLETE && | |
212 | call->state < RXRPC_CALL_NETWORK_ERROR) { | |
213 | call->state = RXRPC_CALL_NETWORK_ERROR; | |
4c198ad1 | 214 | set_bit(RXRPC_CALL_EV_RCVD_ERROR, &call->events); |
651350d1 | 215 | rxrpc_queue_call(call); |
17926a79 DH |
216 | } |
217 | write_unlock(&call->state_lock); | |
218 | list_del_init(&call->error_link); | |
219 | } | |
220 | ||
221 | spin_unlock_bh(&trans->peer->lock); | |
222 | } | |
223 | ||
224 | if (!skb_queue_empty(&trans->error_queue)) | |
651350d1 | 225 | rxrpc_queue_work(&trans->error_handler); |
17926a79 DH |
226 | |
227 | rxrpc_free_skb(skb); | |
228 | rxrpc_put_transport(trans); | |
229 | _leave(""); | |
230 | } |