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 | |
21 | * along with GNU CC; see the file COPYING. If not, write to | |
22 | * the Free Software Foundation, 59 Temple Place - Suite 330, | |
23 | * Boston, MA 02111-1307, USA. | |
24 | * | |
25 | * Please send any bug reports or fixes you make to the | |
26 | * email address(es): | |
27 | * lksctp developers <lksctp-developers@lists.sourceforge.net> | |
28 | * | |
29 | * Or submit a bug report through the following website: | |
30 | * http://www.sf.net/projects/lksctp | |
31 | * | |
32 | * Written or modified by: | |
33 | * Jon Grimm <jgrimm@us.ibm.com> | |
34 | * Sridhar Samudrala <sri@us.ibm.com> | |
35 | * | |
36 | * Any bugs reported given to us we will try to fix... any fixes shared will | |
37 | * be incorporated into the next SCTP release. | |
38 | */ | |
39 | ||
145ce502 JP |
40 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
41 | ||
1da177e4 LT |
42 | #include <linux/types.h> |
43 | #include <linux/kernel.h> | |
44 | #include <linux/net.h> | |
45 | #include <linux/inet.h> | |
46 | #include <linux/skbuff.h> | |
5a0e3ad6 | 47 | #include <linux/slab.h> |
1da177e4 LT |
48 | #include <net/sock.h> |
49 | #include <net/sctp/sctp.h> | |
50 | #include <net/sctp/sm.h> | |
51 | ||
52 | /* This file is mostly in anticipation of future work, but initially | |
53 | * populate with fragment tracking for an outbound message. | |
54 | */ | |
55 | ||
56 | /* Initialize datamsg from memory. */ | |
57 | static void sctp_datamsg_init(struct sctp_datamsg *msg) | |
58 | { | |
59 | atomic_set(&msg->refcnt, 1); | |
60 | msg->send_failed = 0; | |
61 | msg->send_error = 0; | |
62 | msg->can_abandon = 0; | |
0e3aef8d | 63 | msg->can_delay = 1; |
1da177e4 LT |
64 | msg->expires_at = 0; |
65 | INIT_LIST_HEAD(&msg->chunks); | |
66 | } | |
67 | ||
68 | /* Allocate and initialize datamsg. */ | |
dd0fc66f | 69 | SCTP_STATIC struct sctp_datamsg *sctp_datamsg_new(gfp_t gfp) |
1da177e4 LT |
70 | { |
71 | struct sctp_datamsg *msg; | |
72 | msg = kmalloc(sizeof(struct sctp_datamsg), gfp); | |
e8c38751 | 73 | if (msg) { |
1da177e4 | 74 | sctp_datamsg_init(msg); |
e8c38751 LZ |
75 | SCTP_DBG_OBJCNT_INC(datamsg); |
76 | } | |
1da177e4 LT |
77 | return msg; |
78 | } | |
79 | ||
9c5c62be VY |
80 | void sctp_datamsg_free(struct sctp_datamsg *msg) |
81 | { | |
82 | struct sctp_chunk *chunk; | |
83 | ||
84 | /* This doesn't have to be a _safe vairant because | |
85 | * sctp_chunk_free() only drops the refs. | |
86 | */ | |
87 | list_for_each_entry(chunk, &msg->chunks, frag_list) | |
88 | sctp_chunk_free(chunk); | |
89 | ||
90 | sctp_datamsg_put(msg); | |
91 | } | |
92 | ||
1da177e4 LT |
93 | /* Final destructruction of datamsg memory. */ |
94 | static void sctp_datamsg_destroy(struct sctp_datamsg *msg) | |
95 | { | |
96 | struct list_head *pos, *temp; | |
97 | struct sctp_chunk *chunk; | |
98 | struct sctp_sock *sp; | |
99 | struct sctp_ulpevent *ev; | |
100 | struct sctp_association *asoc = NULL; | |
101 | int error = 0, notify; | |
102 | ||
103 | /* If we failed, we may need to notify. */ | |
104 | notify = msg->send_failed ? -1 : 0; | |
105 | ||
106 | /* Release all references. */ | |
107 | list_for_each_safe(pos, temp, &msg->chunks) { | |
108 | list_del_init(pos); | |
109 | chunk = list_entry(pos, struct sctp_chunk, frag_list); | |
110 | /* Check whether we _really_ need to notify. */ | |
111 | if (notify < 0) { | |
112 | asoc = chunk->asoc; | |
113 | if (msg->send_error) | |
114 | error = msg->send_error; | |
115 | else | |
116 | error = asoc->outqueue.error; | |
117 | ||
118 | sp = sctp_sk(asoc->base.sk); | |
119 | notify = sctp_ulpevent_type_enabled(SCTP_SEND_FAILED, | |
120 | &sp->subscribe); | |
121 | } | |
122 | ||
123 | /* Generate a SEND FAILED event only if enabled. */ | |
124 | if (notify > 0) { | |
125 | int sent; | |
126 | if (chunk->has_tsn) | |
127 | sent = SCTP_DATA_SENT; | |
128 | else | |
129 | sent = SCTP_DATA_UNSENT; | |
130 | ||
131 | ev = sctp_ulpevent_make_send_failed(asoc, chunk, sent, | |
132 | error, GFP_ATOMIC); | |
133 | if (ev) | |
134 | sctp_ulpq_tail_event(&asoc->ulpq, ev); | |
135 | } | |
136 | ||
137 | sctp_chunk_put(chunk); | |
138 | } | |
139 | ||
140 | SCTP_DBG_OBJCNT_DEC(datamsg); | |
141 | kfree(msg); | |
142 | } | |
143 | ||
144 | /* Hold a reference. */ | |
145 | static void sctp_datamsg_hold(struct sctp_datamsg *msg) | |
146 | { | |
147 | atomic_inc(&msg->refcnt); | |
148 | } | |
149 | ||
150 | /* Release a reference. */ | |
151 | void sctp_datamsg_put(struct sctp_datamsg *msg) | |
152 | { | |
153 | if (atomic_dec_and_test(&msg->refcnt)) | |
154 | sctp_datamsg_destroy(msg); | |
155 | } | |
156 | ||
1da177e4 LT |
157 | /* Assign a chunk to this datamsg. */ |
158 | static void sctp_datamsg_assign(struct sctp_datamsg *msg, struct sctp_chunk *chunk) | |
159 | { | |
160 | sctp_datamsg_hold(msg); | |
161 | chunk->msg = msg; | |
162 | } | |
163 | ||
164 | ||
165 | /* A data chunk can have a maximum payload of (2^16 - 20). Break | |
166 | * down any such message into smaller chunks. Opportunistically, fragment | |
167 | * the chunks down to the current MTU constraints. We may get refragmented | |
168 | * later if the PMTU changes, but it is _much better_ to fragment immediately | |
169 | * with a reasonable guess than always doing our fragmentation on the | |
170 | * soft-interrupt. | |
171 | */ | |
172 | struct sctp_datamsg *sctp_datamsg_from_user(struct sctp_association *asoc, | |
173 | struct sctp_sndrcvinfo *sinfo, | |
174 | struct msghdr *msgh, int msg_len) | |
175 | { | |
176 | int max, whole, i, offset, over, err; | |
177 | int len, first_len; | |
3e62abf9 | 178 | int max_data; |
1da177e4 LT |
179 | struct sctp_chunk *chunk; |
180 | struct sctp_datamsg *msg; | |
181 | struct list_head *pos, *temp; | |
182 | __u8 frag; | |
183 | ||
184 | msg = sctp_datamsg_new(GFP_KERNEL); | |
185 | if (!msg) | |
6e51fe75 | 186 | return ERR_PTR(-ENOMEM); |
1da177e4 LT |
187 | |
188 | /* Note: Calculate this outside of the loop, so that all fragments | |
189 | * have the same expiration. | |
190 | */ | |
191 | if (sinfo->sinfo_timetolive) { | |
192 | /* sinfo_timetolive is in milliseconds */ | |
193 | msg->expires_at = jiffies + | |
194 | msecs_to_jiffies(sinfo->sinfo_timetolive); | |
195 | msg->can_abandon = 1; | |
196 | SCTP_DEBUG_PRINTK("%s: msg:%p expires_at: %ld jiffies:%ld\n", | |
0dc47877 | 197 | __func__, msg, msg->expires_at, jiffies); |
1da177e4 LT |
198 | } |
199 | ||
3e62abf9 VY |
200 | /* This is the biggest possible DATA chunk that can fit into |
201 | * the packet | |
202 | */ | |
203 | max_data = asoc->pathmtu - | |
204 | sctp_sk(asoc->base.sk)->pf->af->net_header_len - | |
205 | sizeof(struct sctphdr) - sizeof(struct sctp_data_chunk); | |
1da177e4 | 206 | |
3e62abf9 | 207 | max = asoc->frag_point; |
4cd57c80 VY |
208 | /* If the the peer requested that we authenticate DATA chunks |
209 | * we need to accound for bundling of the AUTH chunks along with | |
210 | * DATA. | |
211 | */ | |
212 | if (sctp_auth_send_cid(SCTP_CID_DATA, asoc)) { | |
213 | struct sctp_hmac *hmac_desc = sctp_auth_asoc_get_hmac(asoc); | |
214 | ||
215 | if (hmac_desc) | |
3e62abf9 | 216 | max_data -= WORD_ROUND(sizeof(sctp_auth_chunk_t) + |
4cd57c80 VY |
217 | hmac_desc->hmac_len); |
218 | } | |
219 | ||
3e62abf9 VY |
220 | /* Now, check if we need to reduce our max */ |
221 | if (max > max_data) | |
222 | max = max_data; | |
223 | ||
1da177e4 LT |
224 | whole = 0; |
225 | first_len = max; | |
226 | ||
5d7ff261 VY |
227 | /* Check to see if we have a pending SACK and try to let it be bundled |
228 | * with this message. Do this if we don't have any data queued already. | |
229 | * To check that, look at out_qlen and retransmit list. | |
230 | * NOTE: we will not reduce to account for SACK, if the message would | |
231 | * not have been fragmented. | |
232 | */ | |
233 | if (timer_pending(&asoc->timers[SCTP_EVENT_TIMEOUT_SACK]) && | |
234 | asoc->outqueue.out_qlen == 0 && | |
235 | list_empty(&asoc->outqueue.retransmit) && | |
236 | msg_len > max) | |
237 | max_data -= WORD_ROUND(sizeof(sctp_sack_chunk_t)); | |
238 | ||
1da177e4 | 239 | /* Encourage Cookie-ECHO bundling. */ |
5d7ff261 | 240 | if (asoc->state < SCTP_STATE_COOKIE_ECHOED) |
3e62abf9 | 241 | max_data -= SCTP_ARBITRARY_COOKIE_ECHO_LEN; |
1da177e4 | 242 | |
5d7ff261 VY |
243 | /* Now that we adjusted completely, reset first_len */ |
244 | if (first_len > max_data) | |
245 | first_len = max_data; | |
3e62abf9 VY |
246 | |
247 | /* Account for a different sized first fragment */ | |
248 | if (msg_len >= first_len) { | |
249 | msg_len -= first_len; | |
250 | whole = 1; | |
0e3aef8d | 251 | msg->can_delay = 0; |
1da177e4 LT |
252 | } |
253 | ||
254 | /* How many full sized? How many bytes leftover? */ | |
255 | whole += msg_len / max; | |
256 | over = msg_len % max; | |
257 | offset = 0; | |
258 | ||
259 | if ((whole > 1) || (whole && over)) | |
b01a2407 | 260 | SCTP_INC_STATS_USER(sock_net(asoc->base.sk), SCTP_MIB_FRAGUSRMSGS); |
1da177e4 LT |
261 | |
262 | /* Create chunks for all the full sized DATA chunks. */ | |
263 | for (i=0, len=first_len; i < whole; i++) { | |
264 | frag = SCTP_DATA_MIDDLE_FRAG; | |
265 | ||
266 | if (0 == i) | |
267 | frag |= SCTP_DATA_FIRST_FRAG; | |
268 | ||
b93d6471 | 269 | if ((i == (whole - 1)) && !over) { |
1da177e4 LT |
270 | frag |= SCTP_DATA_LAST_FRAG; |
271 | ||
b93d6471 WY |
272 | /* The application requests to set the I-bit of the |
273 | * last DATA chunk of a user message when providing | |
274 | * the user message to the SCTP implementation. | |
275 | */ | |
276 | if ((sinfo->sinfo_flags & SCTP_EOF) || | |
277 | (sinfo->sinfo_flags & SCTP_SACK_IMMEDIATELY)) | |
278 | frag |= SCTP_DATA_SACK_IMM; | |
279 | } | |
280 | ||
1da177e4 LT |
281 | chunk = sctp_make_datafrag_empty(asoc, sinfo, len, frag, 0); |
282 | ||
6e51fe75 TR |
283 | if (!chunk) { |
284 | err = -ENOMEM; | |
1da177e4 | 285 | goto errout; |
6e51fe75 TR |
286 | } |
287 | ||
1da177e4 LT |
288 | err = sctp_user_addto_chunk(chunk, offset, len, msgh->msg_iov); |
289 | if (err < 0) | |
be364c8c | 290 | goto errout_chunk_free; |
1da177e4 LT |
291 | |
292 | offset += len; | |
293 | ||
294 | /* Put the chunk->skb back into the form expected by send. */ | |
295 | __skb_pull(chunk->skb, (__u8 *)chunk->chunk_hdr | |
296 | - (__u8 *)chunk->skb->data); | |
297 | ||
298 | sctp_datamsg_assign(msg, chunk); | |
299 | list_add_tail(&chunk->frag_list, &msg->chunks); | |
300 | ||
301 | /* The first chunk, the first chunk was likely short | |
302 | * to allow bundling, so reset to full size. | |
303 | */ | |
304 | if (0 == i) | |
305 | len = max; | |
306 | } | |
307 | ||
308 | /* .. now the leftover bytes. */ | |
309 | if (over) { | |
310 | if (!whole) | |
311 | frag = SCTP_DATA_NOT_FRAG; | |
312 | else | |
313 | frag = SCTP_DATA_LAST_FRAG; | |
314 | ||
b93d6471 WY |
315 | if ((sinfo->sinfo_flags & SCTP_EOF) || |
316 | (sinfo->sinfo_flags & SCTP_SACK_IMMEDIATELY)) | |
317 | frag |= SCTP_DATA_SACK_IMM; | |
318 | ||
1da177e4 LT |
319 | chunk = sctp_make_datafrag_empty(asoc, sinfo, over, frag, 0); |
320 | ||
6e51fe75 TR |
321 | if (!chunk) { |
322 | err = -ENOMEM; | |
1da177e4 | 323 | goto errout; |
6e51fe75 | 324 | } |
1da177e4 LT |
325 | |
326 | err = sctp_user_addto_chunk(chunk, offset, over,msgh->msg_iov); | |
327 | ||
328 | /* Put the chunk->skb back into the form expected by send. */ | |
329 | __skb_pull(chunk->skb, (__u8 *)chunk->chunk_hdr | |
330 | - (__u8 *)chunk->skb->data); | |
331 | if (err < 0) | |
be364c8c | 332 | goto errout_chunk_free; |
1da177e4 LT |
333 | |
334 | sctp_datamsg_assign(msg, chunk); | |
335 | list_add_tail(&chunk->frag_list, &msg->chunks); | |
336 | } | |
337 | ||
338 | return msg; | |
339 | ||
be364c8c TR |
340 | errout_chunk_free: |
341 | sctp_chunk_free(chunk); | |
342 | ||
1da177e4 LT |
343 | errout: |
344 | list_for_each_safe(pos, temp, &msg->chunks) { | |
345 | list_del_init(pos); | |
346 | chunk = list_entry(pos, struct sctp_chunk, frag_list); | |
347 | sctp_chunk_free(chunk); | |
348 | } | |
80445cfb | 349 | sctp_datamsg_put(msg); |
6e51fe75 | 350 | return ERR_PTR(err); |
1da177e4 LT |
351 | } |
352 | ||
353 | /* Check whether this message has expired. */ | |
354 | int sctp_chunk_abandoned(struct sctp_chunk *chunk) | |
355 | { | |
356 | struct sctp_datamsg *msg = chunk->msg; | |
357 | ||
358 | if (!msg->can_abandon) | |
359 | return 0; | |
360 | ||
361 | if (time_after(jiffies, msg->expires_at)) | |
362 | return 1; | |
363 | ||
364 | return 0; | |
365 | } | |
366 | ||
367 | /* This chunk (and consequently entire message) has failed in its sending. */ | |
368 | void sctp_chunk_fail(struct sctp_chunk *chunk, int error) | |
369 | { | |
370 | chunk->msg->send_failed = 1; | |
371 | chunk->msg->send_error = error; | |
372 | } |