]>
Commit | Line | Data |
---|---|---|
60c778b2 | 1 | /* SCTP kernel implementation |
1da177e4 LT |
2 | * (C) Copyright IBM Corp. 2003, 2004 |
3 | * | |
60c778b2 | 4 | * This file is part of the SCTP kernel implementation |
1da177e4 | 5 | * |
59c51591 | 6 | * This file contains the code relating the chunk abstraction. |
1da177e4 | 7 | * |
60c778b2 | 8 | * This SCTP implementation is free software; |
1da177e4 LT |
9 | * you can redistribute it and/or modify it under the terms of |
10 | * the GNU General Public License as published by | |
11 | * the Free Software Foundation; either version 2, or (at your option) | |
12 | * any later version. | |
13 | * | |
60c778b2 | 14 | * This SCTP implementation is distributed in the hope that it |
1da177e4 LT |
15 | * will be useful, but WITHOUT ANY WARRANTY; without even the implied |
16 | * ************************ | |
17 | * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. | |
18 | * See the GNU General Public License for more details. | |
19 | * | |
20 | * You should have received a copy of the GNU General Public License | |
4b2f13a2 JK |
21 | * along with GNU CC; see the file COPYING. If not, see |
22 | * <http://www.gnu.org/licenses/>. | |
1da177e4 LT |
23 | * |
24 | * Please send any bug reports or fixes you make to the | |
25 | * email address(es): | |
91705c61 | 26 | * lksctp developers <linux-sctp@vger.kernel.org> |
1da177e4 | 27 | * |
1da177e4 LT |
28 | * Written or modified by: |
29 | * Jon Grimm <jgrimm@us.ibm.com> | |
30 | * Sridhar Samudrala <sri@us.ibm.com> | |
1da177e4 LT |
31 | */ |
32 | ||
145ce502 JP |
33 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
34 | ||
1da177e4 LT |
35 | #include <linux/types.h> |
36 | #include <linux/kernel.h> | |
37 | #include <linux/net.h> | |
38 | #include <linux/inet.h> | |
39 | #include <linux/skbuff.h> | |
5a0e3ad6 | 40 | #include <linux/slab.h> |
1da177e4 LT |
41 | #include <net/sock.h> |
42 | #include <net/sctp/sctp.h> | |
43 | #include <net/sctp/sm.h> | |
44 | ||
45 | /* This file is mostly in anticipation of future work, but initially | |
46 | * populate with fragment tracking for an outbound message. | |
47 | */ | |
48 | ||
49 | /* Initialize datamsg from memory. */ | |
50 | static void sctp_datamsg_init(struct sctp_datamsg *msg) | |
51 | { | |
c0acdfb4 | 52 | refcount_set(&msg->refcnt, 1); |
1da177e4 LT |
53 | msg->send_failed = 0; |
54 | msg->send_error = 0; | |
0e3aef8d | 55 | msg->can_delay = 1; |
e5f61296 | 56 | msg->abandoned = 0; |
1da177e4 LT |
57 | msg->expires_at = 0; |
58 | INIT_LIST_HEAD(&msg->chunks); | |
59 | } | |
60 | ||
61 | /* Allocate and initialize datamsg. */ | |
dda91928 | 62 | static struct sctp_datamsg *sctp_datamsg_new(gfp_t gfp) |
1da177e4 LT |
63 | { |
64 | struct sctp_datamsg *msg; | |
65 | msg = kmalloc(sizeof(struct sctp_datamsg), gfp); | |
e8c38751 | 66 | if (msg) { |
1da177e4 | 67 | sctp_datamsg_init(msg); |
e8c38751 LZ |
68 | SCTP_DBG_OBJCNT_INC(datamsg); |
69 | } | |
1da177e4 LT |
70 | return msg; |
71 | } | |
72 | ||
b61c654f XL |
73 | void sctp_datamsg_free(struct sctp_datamsg *msg) |
74 | { | |
75 | struct sctp_chunk *chunk; | |
76 | ||
77 | /* This doesn't have to be a _safe vairant because | |
78 | * sctp_chunk_free() only drops the refs. | |
79 | */ | |
80 | list_for_each_entry(chunk, &msg->chunks, frag_list) | |
81 | sctp_chunk_free(chunk); | |
82 | ||
83 | sctp_datamsg_put(msg); | |
84 | } | |
85 | ||
1da177e4 LT |
86 | /* Final destructruction of datamsg memory. */ |
87 | static void sctp_datamsg_destroy(struct sctp_datamsg *msg) | |
88 | { | |
89 | struct list_head *pos, *temp; | |
90 | struct sctp_chunk *chunk; | |
91 | struct sctp_sock *sp; | |
92 | struct sctp_ulpevent *ev; | |
93 | struct sctp_association *asoc = NULL; | |
94 | int error = 0, notify; | |
95 | ||
96 | /* If we failed, we may need to notify. */ | |
97 | notify = msg->send_failed ? -1 : 0; | |
98 | ||
99 | /* Release all references. */ | |
100 | list_for_each_safe(pos, temp, &msg->chunks) { | |
101 | list_del_init(pos); | |
102 | chunk = list_entry(pos, struct sctp_chunk, frag_list); | |
103 | /* Check whether we _really_ need to notify. */ | |
104 | if (notify < 0) { | |
105 | asoc = chunk->asoc; | |
106 | if (msg->send_error) | |
107 | error = msg->send_error; | |
108 | else | |
109 | error = asoc->outqueue.error; | |
110 | ||
111 | sp = sctp_sk(asoc->base.sk); | |
112 | notify = sctp_ulpevent_type_enabled(SCTP_SEND_FAILED, | |
113 | &sp->subscribe); | |
114 | } | |
115 | ||
116 | /* Generate a SEND FAILED event only if enabled. */ | |
117 | if (notify > 0) { | |
118 | int sent; | |
119 | if (chunk->has_tsn) | |
120 | sent = SCTP_DATA_SENT; | |
121 | else | |
122 | sent = SCTP_DATA_UNSENT; | |
123 | ||
124 | ev = sctp_ulpevent_make_send_failed(asoc, chunk, sent, | |
125 | error, GFP_ATOMIC); | |
126 | if (ev) | |
9162e0ed | 127 | asoc->stream.si->enqueue_event(&asoc->ulpq, ev); |
1da177e4 LT |
128 | } |
129 | ||
130 | sctp_chunk_put(chunk); | |
131 | } | |
132 | ||
133 | SCTP_DBG_OBJCNT_DEC(datamsg); | |
134 | kfree(msg); | |
135 | } | |
136 | ||
137 | /* Hold a reference. */ | |
138 | static void sctp_datamsg_hold(struct sctp_datamsg *msg) | |
139 | { | |
c0acdfb4 | 140 | refcount_inc(&msg->refcnt); |
1da177e4 LT |
141 | } |
142 | ||
143 | /* Release a reference. */ | |
144 | void sctp_datamsg_put(struct sctp_datamsg *msg) | |
145 | { | |
c0acdfb4 | 146 | if (refcount_dec_and_test(&msg->refcnt)) |
1da177e4 LT |
147 | sctp_datamsg_destroy(msg); |
148 | } | |
149 | ||
1da177e4 LT |
150 | /* Assign a chunk to this datamsg. */ |
151 | static void sctp_datamsg_assign(struct sctp_datamsg *msg, struct sctp_chunk *chunk) | |
152 | { | |
153 | sctp_datamsg_hold(msg); | |
154 | chunk->msg = msg; | |
155 | } | |
156 | ||
157 | ||
158 | /* A data chunk can have a maximum payload of (2^16 - 20). Break | |
159 | * down any such message into smaller chunks. Opportunistically, fragment | |
160 | * the chunks down to the current MTU constraints. We may get refragmented | |
161 | * later if the PMTU changes, but it is _much better_ to fragment immediately | |
162 | * with a reasonable guess than always doing our fragmentation on the | |
163 | * soft-interrupt. | |
164 | */ | |
165 | struct sctp_datamsg *sctp_datamsg_from_user(struct sctp_association *asoc, | |
166 | struct sctp_sndrcvinfo *sinfo, | |
e0eb093e | 167 | struct iov_iter *from) |
1da177e4 | 168 | { |
bfd2e4b8 MRL |
169 | size_t len, first_len, max_data, remaining; |
170 | size_t msg_len = iov_iter_count(from); | |
171 | struct list_head *pos, *temp; | |
1da177e4 LT |
172 | struct sctp_chunk *chunk; |
173 | struct sctp_datamsg *msg; | |
bfd2e4b8 | 174 | int err; |
1da177e4 LT |
175 | |
176 | msg = sctp_datamsg_new(GFP_KERNEL); | |
177 | if (!msg) | |
6e51fe75 | 178 | return ERR_PTR(-ENOMEM); |
1da177e4 LT |
179 | |
180 | /* Note: Calculate this outside of the loop, so that all fragments | |
181 | * have the same expiration. | |
182 | */ | |
8ae808eb XL |
183 | if (asoc->peer.prsctp_capable && sinfo->sinfo_timetolive && |
184 | (SCTP_PR_TTL_ENABLED(sinfo->sinfo_flags) || | |
185 | !SCTP_PR_POLICY(sinfo->sinfo_flags))) | |
1da177e4 | 186 | msg->expires_at = jiffies + |
bfd2e4b8 | 187 | msecs_to_jiffies(sinfo->sinfo_timetolive); |
0605483f | 188 | |
3e62abf9 VY |
189 | /* This is the biggest possible DATA chunk that can fit into |
190 | * the packet | |
191 | */ | |
4a225ce3 MRL |
192 | max_data = asoc->pathmtu - |
193 | sctp_sk(asoc->base.sk)->pf->af->net_header_len - | |
0c3f6f65 | 194 | sizeof(struct sctphdr) - sctp_datachk_len(&asoc->stream); |
4a225ce3 | 195 | max_data = SCTP_TRUNC4(max_data); |
1da177e4 | 196 | |
4cd57c80 | 197 | /* If the the peer requested that we authenticate DATA chunks |
2bccbadf | 198 | * we need to account for bundling of the AUTH chunks along with |
4cd57c80 VY |
199 | * DATA. |
200 | */ | |
201 | if (sctp_auth_send_cid(SCTP_CID_DATA, asoc)) { | |
202 | struct sctp_hmac *hmac_desc = sctp_auth_asoc_get_hmac(asoc); | |
203 | ||
204 | if (hmac_desc) | |
bb96dec7 | 205 | max_data -= SCTP_PAD4(sizeof(struct sctp_auth_chunk) + |
e2f036a9 | 206 | hmac_desc->hmac_len); |
4cd57c80 VY |
207 | } |
208 | ||
bfd2e4b8 MRL |
209 | /* Check what's our max considering the above */ |
210 | max_data = min_t(size_t, max_data, asoc->frag_point); | |
3e62abf9 | 211 | |
bfd2e4b8 MRL |
212 | /* Set first_len and then account for possible bundles on first frag */ |
213 | first_len = max_data; | |
1da177e4 | 214 | |
5d7ff261 VY |
215 | /* Check to see if we have a pending SACK and try to let it be bundled |
216 | * with this message. Do this if we don't have any data queued already. | |
217 | * To check that, look at out_qlen and retransmit list. | |
218 | * NOTE: we will not reduce to account for SACK, if the message would | |
219 | * not have been fragmented. | |
220 | */ | |
221 | if (timer_pending(&asoc->timers[SCTP_EVENT_TIMEOUT_SACK]) && | |
222 | asoc->outqueue.out_qlen == 0 && | |
223 | list_empty(&asoc->outqueue.retransmit) && | |
bfd2e4b8 | 224 | msg_len > max_data) |
d4d6c614 | 225 | first_len -= SCTP_PAD4(sizeof(struct sctp_sack_chunk)); |
5d7ff261 | 226 | |
1da177e4 | 227 | /* Encourage Cookie-ECHO bundling. */ |
5d7ff261 | 228 | if (asoc->state < SCTP_STATE_COOKIE_ECHOED) |
bfd2e4b8 | 229 | first_len -= SCTP_ARBITRARY_COOKIE_ECHO_LEN; |
3e62abf9 VY |
230 | |
231 | /* Account for a different sized first fragment */ | |
232 | if (msg_len >= first_len) { | |
0e3aef8d | 233 | msg->can_delay = 0; |
6aef70a8 | 234 | SCTP_INC_STATS(sock_net(asoc->base.sk), SCTP_MIB_FRAGUSRMSGS); |
bfd2e4b8 MRL |
235 | } else { |
236 | /* Which may be the only one... */ | |
237 | first_len = msg_len; | |
238 | } | |
1da177e4 | 239 | |
bfd2e4b8 MRL |
240 | /* Create chunks for all DATA chunks. */ |
241 | for (remaining = msg_len; remaining; remaining -= len) { | |
242 | u8 frag = SCTP_DATA_MIDDLE_FRAG; | |
1da177e4 | 243 | |
bfd2e4b8 MRL |
244 | if (remaining == msg_len) { |
245 | /* First frag, which may also be the last */ | |
1da177e4 | 246 | frag |= SCTP_DATA_FIRST_FRAG; |
bfd2e4b8 MRL |
247 | len = first_len; |
248 | } else { | |
249 | /* Middle frags */ | |
250 | len = max_data; | |
251 | } | |
1da177e4 | 252 | |
bfd2e4b8 MRL |
253 | if (len >= remaining) { |
254 | /* Last frag, which may also be the first */ | |
255 | len = remaining; | |
1da177e4 LT |
256 | frag |= SCTP_DATA_LAST_FRAG; |
257 | ||
b93d6471 WY |
258 | /* The application requests to set the I-bit of the |
259 | * last DATA chunk of a user message when providing | |
260 | * the user message to the SCTP implementation. | |
261 | */ | |
262 | if ((sinfo->sinfo_flags & SCTP_EOF) || | |
263 | (sinfo->sinfo_flags & SCTP_SACK_IMMEDIATELY)) | |
264 | frag |= SCTP_DATA_SACK_IMM; | |
265 | } | |
266 | ||
0c3f6f65 XL |
267 | chunk = asoc->stream.si->make_datafrag(asoc, sinfo, len, frag, |
268 | GFP_KERNEL); | |
6e51fe75 TR |
269 | if (!chunk) { |
270 | err = -ENOMEM; | |
1da177e4 | 271 | goto errout; |
6e51fe75 TR |
272 | } |
273 | ||
e0eb093e | 274 | err = sctp_user_addto_chunk(chunk, len, from); |
1da177e4 | 275 | if (err < 0) |
be364c8c | 276 | goto errout_chunk_free; |
1da177e4 | 277 | |
1da177e4 | 278 | /* Put the chunk->skb back into the form expected by send. */ |
bfd2e4b8 MRL |
279 | __skb_pull(chunk->skb, (__u8 *)chunk->chunk_hdr - |
280 | chunk->skb->data); | |
1da177e4 LT |
281 | |
282 | sctp_datamsg_assign(msg, chunk); | |
283 | list_add_tail(&chunk->frag_list, &msg->chunks); | |
284 | } | |
285 | ||
286 | return msg; | |
287 | ||
be364c8c TR |
288 | errout_chunk_free: |
289 | sctp_chunk_free(chunk); | |
290 | ||
1da177e4 LT |
291 | errout: |
292 | list_for_each_safe(pos, temp, &msg->chunks) { | |
293 | list_del_init(pos); | |
294 | chunk = list_entry(pos, struct sctp_chunk, frag_list); | |
295 | sctp_chunk_free(chunk); | |
296 | } | |
80445cfb | 297 | sctp_datamsg_put(msg); |
bfd2e4b8 | 298 | |
6e51fe75 | 299 | return ERR_PTR(err); |
1da177e4 LT |
300 | } |
301 | ||
302 | /* Check whether this message has expired. */ | |
303 | int sctp_chunk_abandoned(struct sctp_chunk *chunk) | |
304 | { | |
8ae808eb | 305 | if (!chunk->asoc->peer.prsctp_capable) |
1da177e4 LT |
306 | return 0; |
307 | ||
e5f61296 XL |
308 | if (chunk->msg->abandoned) |
309 | return 1; | |
310 | ||
779edd73 XL |
311 | if (!chunk->has_tsn && |
312 | !(chunk->chunk_hdr->flags & SCTP_DATA_FIRST_FRAG)) | |
313 | return 0; | |
314 | ||
a6c2f792 | 315 | if (SCTP_PR_TTL_ENABLED(chunk->sinfo.sinfo_flags) && |
0605483f | 316 | time_after(jiffies, chunk->msg->expires_at)) { |
d229d48d | 317 | struct sctp_stream_out *streamout = |
cee360ab | 318 | &chunk->asoc->stream.out[chunk->sinfo.sinfo_stream]; |
d229d48d XL |
319 | |
320 | if (chunk->sent_count) { | |
a6c2f792 | 321 | chunk->asoc->abandoned_sent[SCTP_PR_INDEX(TTL)]++; |
f952be79 | 322 | streamout->ext->abandoned_sent[SCTP_PR_INDEX(TTL)]++; |
d229d48d | 323 | } else { |
a6c2f792 | 324 | chunk->asoc->abandoned_unsent[SCTP_PR_INDEX(TTL)]++; |
f952be79 | 325 | streamout->ext->abandoned_unsent[SCTP_PR_INDEX(TTL)]++; |
d229d48d | 326 | } |
e5f61296 | 327 | chunk->msg->abandoned = 1; |
1da177e4 | 328 | return 1; |
01aadb3a | 329 | } else if (SCTP_PR_RTX_ENABLED(chunk->sinfo.sinfo_flags) && |
0605483f | 330 | chunk->sent_count > chunk->sinfo.sinfo_timetolive) { |
d229d48d | 331 | struct sctp_stream_out *streamout = |
cee360ab | 332 | &chunk->asoc->stream.out[chunk->sinfo.sinfo_stream]; |
d229d48d | 333 | |
01aadb3a | 334 | chunk->asoc->abandoned_sent[SCTP_PR_INDEX(RTX)]++; |
f952be79 | 335 | streamout->ext->abandoned_sent[SCTP_PR_INDEX(RTX)]++; |
e5f61296 | 336 | chunk->msg->abandoned = 1; |
01aadb3a | 337 | return 1; |
8ae808eb XL |
338 | } else if (!SCTP_PR_POLICY(chunk->sinfo.sinfo_flags) && |
339 | chunk->msg->expires_at && | |
340 | time_after(jiffies, chunk->msg->expires_at)) { | |
e5f61296 | 341 | chunk->msg->abandoned = 1; |
8ae808eb | 342 | return 1; |
a6c2f792 | 343 | } |
8dbdf1f5 | 344 | /* PRIO policy is processed by sendmsg, not here */ |
1da177e4 LT |
345 | |
346 | return 0; | |
347 | } | |
348 | ||
349 | /* This chunk (and consequently entire message) has failed in its sending. */ | |
350 | void sctp_chunk_fail(struct sctp_chunk *chunk, int error) | |
351 | { | |
352 | chunk->msg->send_failed = 1; | |
353 | chunk->msg->send_error = error; | |
354 | } |