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