1 /* SCTP kernel implementation
2 * (C) Copyright IBM Corp. 2003, 2004
4 * This file is part of the SCTP kernel implementation
6 * This file contains the code relating the chunk abstraction.
8 * This SCTP implementation is free software;
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)
14 * This SCTP implementation is distributed in the hope that it
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.
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.
25 * Please send any bug reports or fixes you make to the
27 * lksctp developers <lksctp-developers@lists.sourceforge.net>
29 * Or submit a bug report through the following website:
30 * http://www.sf.net/projects/lksctp
32 * Written or modified by:
33 * Jon Grimm <jgrimm@us.ibm.com>
34 * Sridhar Samudrala <sri@us.ibm.com>
36 * Any bugs reported given to us we will try to fix... any fixes shared will
37 * be incorporated into the next SCTP release.
40 #include <linux/types.h>
41 #include <linux/kernel.h>
42 #include <linux/net.h>
43 #include <linux/inet.h>
44 #include <linux/skbuff.h>
46 #include <net/sctp/sctp.h>
47 #include <net/sctp/sm.h>
49 /* This file is mostly in anticipation of future work, but initially
50 * populate with fragment tracking for an outbound message.
53 /* Initialize datamsg from memory. */
54 static void sctp_datamsg_init(struct sctp_datamsg
*msg
)
56 atomic_set(&msg
->refcnt
, 1);
61 INIT_LIST_HEAD(&msg
->chunks
);
64 /* Allocate and initialize datamsg. */
65 SCTP_STATIC
struct sctp_datamsg
*sctp_datamsg_new(gfp_t gfp
)
67 struct sctp_datamsg
*msg
;
68 msg
= kmalloc(sizeof(struct sctp_datamsg
), gfp
);
70 sctp_datamsg_init(msg
);
71 SCTP_DBG_OBJCNT_INC(datamsg
);
75 /* Final destructruction of datamsg memory. */
76 static void sctp_datamsg_destroy(struct sctp_datamsg
*msg
)
78 struct list_head
*pos
, *temp
;
79 struct sctp_chunk
*chunk
;
81 struct sctp_ulpevent
*ev
;
82 struct sctp_association
*asoc
= NULL
;
83 int error
= 0, notify
;
85 /* If we failed, we may need to notify. */
86 notify
= msg
->send_failed
? -1 : 0;
88 /* Release all references. */
89 list_for_each_safe(pos
, temp
, &msg
->chunks
) {
91 chunk
= list_entry(pos
, struct sctp_chunk
, frag_list
);
92 /* Check whether we _really_ need to notify. */
96 error
= msg
->send_error
;
98 error
= asoc
->outqueue
.error
;
100 sp
= sctp_sk(asoc
->base
.sk
);
101 notify
= sctp_ulpevent_type_enabled(SCTP_SEND_FAILED
,
105 /* Generate a SEND FAILED event only if enabled. */
109 sent
= SCTP_DATA_SENT
;
111 sent
= SCTP_DATA_UNSENT
;
113 ev
= sctp_ulpevent_make_send_failed(asoc
, chunk
, sent
,
116 sctp_ulpq_tail_event(&asoc
->ulpq
, ev
);
119 sctp_chunk_put(chunk
);
122 SCTP_DBG_OBJCNT_DEC(datamsg
);
126 /* Hold a reference. */
127 static void sctp_datamsg_hold(struct sctp_datamsg
*msg
)
129 atomic_inc(&msg
->refcnt
);
132 /* Release a reference. */
133 void sctp_datamsg_put(struct sctp_datamsg
*msg
)
135 if (atomic_dec_and_test(&msg
->refcnt
))
136 sctp_datamsg_destroy(msg
);
139 /* Assign a chunk to this datamsg. */
140 static void sctp_datamsg_assign(struct sctp_datamsg
*msg
, struct sctp_chunk
*chunk
)
142 sctp_datamsg_hold(msg
);
147 /* A data chunk can have a maximum payload of (2^16 - 20). Break
148 * down any such message into smaller chunks. Opportunistically, fragment
149 * the chunks down to the current MTU constraints. We may get refragmented
150 * later if the PMTU changes, but it is _much better_ to fragment immediately
151 * with a reasonable guess than always doing our fragmentation on the
154 struct sctp_datamsg
*sctp_datamsg_from_user(struct sctp_association
*asoc
,
155 struct sctp_sndrcvinfo
*sinfo
,
156 struct msghdr
*msgh
, int msg_len
)
158 int max
, whole
, i
, offset
, over
, err
;
160 struct sctp_chunk
*chunk
;
161 struct sctp_datamsg
*msg
;
162 struct list_head
*pos
, *temp
;
165 msg
= sctp_datamsg_new(GFP_KERNEL
);
169 /* Note: Calculate this outside of the loop, so that all fragments
170 * have the same expiration.
172 if (sinfo
->sinfo_timetolive
) {
173 /* sinfo_timetolive is in milliseconds */
174 msg
->expires_at
= jiffies
+
175 msecs_to_jiffies(sinfo
->sinfo_timetolive
);
176 msg
->can_abandon
= 1;
177 SCTP_DEBUG_PRINTK("%s: msg:%p expires_at: %ld jiffies:%ld\n",
178 __func__
, msg
, msg
->expires_at
, jiffies
);
181 max
= asoc
->frag_point
;
183 /* If the the peer requested that we authenticate DATA chunks
184 * we need to accound for bundling of the AUTH chunks along with
187 if (sctp_auth_send_cid(SCTP_CID_DATA
, asoc
)) {
188 struct sctp_hmac
*hmac_desc
= sctp_auth_asoc_get_hmac(asoc
);
191 max
-= WORD_ROUND(sizeof(sctp_auth_chunk_t
) +
192 hmac_desc
->hmac_len
);
198 /* Encourage Cookie-ECHO bundling. */
199 if (asoc
->state
< SCTP_STATE_COOKIE_ECHOED
) {
200 whole
= msg_len
/ (max
- SCTP_ARBITRARY_COOKIE_ECHO_LEN
);
202 /* Account for the DATA to be bundled with the COOKIE-ECHO. */
204 first_len
= max
- SCTP_ARBITRARY_COOKIE_ECHO_LEN
;
205 msg_len
-= first_len
;
210 /* How many full sized? How many bytes leftover? */
211 whole
+= msg_len
/ max
;
212 over
= msg_len
% max
;
215 if ((whole
> 1) || (whole
&& over
))
216 SCTP_INC_STATS_USER(SCTP_MIB_FRAGUSRMSGS
);
218 /* Create chunks for all the full sized DATA chunks. */
219 for (i
=0, len
=first_len
; i
< whole
; i
++) {
220 frag
= SCTP_DATA_MIDDLE_FRAG
;
223 frag
|= SCTP_DATA_FIRST_FRAG
;
225 if ((i
== (whole
- 1)) && !over
)
226 frag
|= SCTP_DATA_LAST_FRAG
;
228 chunk
= sctp_make_datafrag_empty(asoc
, sinfo
, len
, frag
, 0);
232 err
= sctp_user_addto_chunk(chunk
, offset
, len
, msgh
->msg_iov
);
238 /* Put the chunk->skb back into the form expected by send. */
239 __skb_pull(chunk
->skb
, (__u8
*)chunk
->chunk_hdr
240 - (__u8
*)chunk
->skb
->data
);
242 sctp_datamsg_assign(msg
, chunk
);
243 list_add_tail(&chunk
->frag_list
, &msg
->chunks
);
245 /* The first chunk, the first chunk was likely short
246 * to allow bundling, so reset to full size.
252 /* .. now the leftover bytes. */
255 frag
= SCTP_DATA_NOT_FRAG
;
257 frag
= SCTP_DATA_LAST_FRAG
;
259 chunk
= sctp_make_datafrag_empty(asoc
, sinfo
, over
, frag
, 0);
264 err
= sctp_user_addto_chunk(chunk
, offset
, over
,msgh
->msg_iov
);
266 /* Put the chunk->skb back into the form expected by send. */
267 __skb_pull(chunk
->skb
, (__u8
*)chunk
->chunk_hdr
268 - (__u8
*)chunk
->skb
->data
);
272 sctp_datamsg_assign(msg
, chunk
);
273 list_add_tail(&chunk
->frag_list
, &msg
->chunks
);
279 list_for_each_safe(pos
, temp
, &msg
->chunks
) {
281 chunk
= list_entry(pos
, struct sctp_chunk
, frag_list
);
282 sctp_chunk_free(chunk
);
284 sctp_datamsg_put(msg
);
288 /* Check whether this message has expired. */
289 int sctp_chunk_abandoned(struct sctp_chunk
*chunk
)
291 struct sctp_datamsg
*msg
= chunk
->msg
;
293 if (!msg
->can_abandon
)
296 if (time_after(jiffies
, msg
->expires_at
))
302 /* This chunk (and consequently entire message) has failed in its sending. */
303 void sctp_chunk_fail(struct sctp_chunk
*chunk
, int error
)
305 chunk
->msg
->send_failed
= 1;
306 chunk
->msg
->send_error
= error
;