1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 #include <sys/types.h>
27 #include <sys/systm.h>
28 #include <sys/stream.h>
29 #include <sys/cmn_err.h>
30 #include <sys/tihdr.h>
31 #include <sys/kmem.h>
32 #define	_SUN_TPI_VERSION 2
33 #include <sys/tihdr.h>
34 #include <sys/socket.h>
35 
36 #include <netinet/in.h>
37 #include <netinet/sctp.h>
38 
39 #include <inet/common.h>
40 #include <inet/ipclassifier.h>
41 #include <inet/ip.h>
42 
43 #include "sctp_impl.h"
44 
45 /* ARGSUSED */
46 static void
47 sctp_notify(sctp_t *sctp, mblk_t *emp, size_t len)
48 {
49 	struct T_unitdata_ind *tudi;
50 	mblk_t *mp;
51 	sctp_faddr_t *fp;
52 	int32_t rwnd = 0;
53 	int error;
54 	conn_t *connp = sctp->sctp_connp;
55 
56 	if ((mp = allocb(sizeof (*tudi) + sizeof (void *) +
57 		sizeof (struct sockaddr_in6), BPRI_HI)) == NULL) {
58 		/* XXX trouble: don't want to drop events. should queue it. */
59 		freemsg(emp);
60 		return;
61 	}
62 	dprint(3, ("sctp_notify: event %d\n", (*(uint16_t *)emp->b_rptr)));
63 
64 	mp->b_datap->db_type = M_PROTO;
65 	mp->b_flag |= MSGMARK;
66 	mp->b_rptr += sizeof (void *); /* pointer worth of padding */
67 
68 	tudi = (struct T_unitdata_ind *)mp->b_rptr;
69 	tudi->PRIM_type = T_UNITDATA_IND;
70 	tudi->SRC_offset = sizeof (*tudi);
71 	tudi->OPT_length = 0;
72 	tudi->OPT_offset = 0;
73 
74 	fp = sctp->sctp_primary;
75 	ASSERT(fp);
76 
77 	/*
78 	 * Fill in primary remote address.
79 	 */
80 	if (IN6_IS_ADDR_V4MAPPED(&fp->faddr)) {
81 		struct sockaddr_in *sin4;
82 
83 		tudi->SRC_length = sizeof (*sin4);
84 		sin4 = (struct sockaddr_in *)(tudi + 1);
85 		sin4->sin_family = AF_INET;
86 		sin4->sin_port = connp->conn_fport;
87 		IN6_V4MAPPED_TO_IPADDR(&fp->faddr, sin4->sin_addr.s_addr);
88 		mp->b_wptr = (uchar_t *)(sin4 + 1);
89 	} else {
90 		struct sockaddr_in6 *sin6;
91 
92 		tudi->SRC_length = sizeof (*sin6);
93 		sin6 = (struct sockaddr_in6 *)(tudi + 1);
94 		sin6->sin6_family = AF_INET6;
95 		sin6->sin6_port = connp->conn_fport;
96 		sin6->sin6_addr = fp->faddr;
97 		mp->b_wptr = (uchar_t *)(sin6 + 1);
98 	}
99 
100 	mp->b_cont = emp;
101 
102 	/*
103 	 * Notifications are queued regardless of socket rx space.  So
104 	 * we do not decrement sctp_rwnd here as this will confuse the
105 	 * other side.
106 	 */
107 #ifdef DEBUG
108 	for (emp = mp->b_cont; emp; emp = emp->b_cont) {
109 		rwnd += emp->b_wptr - emp->b_rptr;
110 	}
111 	ASSERT(len == rwnd);
112 #endif
113 
114 	/*
115 	 * Override b_flag for SCTP sockfs internal use
116 	 */
117 	mp->b_flag = (short)SCTP_NOTIFICATION;
118 
119 	rwnd = sctp->sctp_ulp_recv(sctp->sctp_ulpd, mp, msgdsize(mp), 0,
120 	    &error, NULL);
121 	if (rwnd > sctp->sctp_rwnd) {
122 		sctp->sctp_rwnd = rwnd;
123 	}
124 }
125 
126 void
127 sctp_assoc_event(sctp_t *sctp, uint16_t state, uint16_t error,
128     sctp_chunk_hdr_t *ch)
129 {
130 	struct sctp_assoc_change *sacp;
131 	mblk_t *mp;
132 	uint16_t ch_len;
133 
134 	if (!sctp->sctp_recvassocevnt) {
135 		return;
136 	}
137 
138 	ch_len = (ch != NULL) ? ntohs(ch->sch_len) : 0;
139 
140 	if ((mp = allocb(sizeof (*sacp) + ch_len, BPRI_MED)) == NULL) {
141 		return;
142 	}
143 
144 	sacp = (struct sctp_assoc_change *)mp->b_rptr;
145 	sacp->sac_type = SCTP_ASSOC_CHANGE;
146 	sacp->sac_flags = sctp->sctp_prsctp_aware ? SCTP_PRSCTP_CAPABLE : 0;
147 	sacp->sac_length = sizeof (*sacp) + ch_len;
148 	sacp->sac_state = state;
149 	sacp->sac_error = error;
150 	sacp->sac_outbound_streams = sctp->sctp_num_ostr;
151 	sacp->sac_inbound_streams = sctp->sctp_num_istr;
152 	sacp->sac_assoc_id = 0;
153 
154 	if (ch != NULL)
155 		bcopy(ch, sacp + 1, ch_len);
156 	mp->b_wptr += sacp->sac_length;
157 	sctp_notify(sctp, mp, sacp->sac_length);
158 }
159 
160 /*
161  * Send failure event. Message is expected to have message header still
162  * in place, data follows in subsequent mblk's.
163  */
164 static void
165 sctp_sendfail(sctp_t *sctp, mblk_t *msghdr, uint16_t flags, int error)
166 {
167 	struct sctp_send_failed *sfp;
168 	mblk_t *mp;
169 	sctp_msg_hdr_t *smh;
170 
171 	/* Allocate a mblk for the notification header */
172 	if ((mp = allocb(sizeof (*sfp), BPRI_MED)) == NULL) {
173 		/* give up */
174 		freemsg(msghdr);
175 		return;
176 	}
177 
178 	smh = (sctp_msg_hdr_t *)msghdr->b_rptr;
179 	sfp = (struct sctp_send_failed *)mp->b_rptr;
180 	sfp->ssf_type = SCTP_SEND_FAILED;
181 	sfp->ssf_flags = flags;
182 	sfp->ssf_length = smh->smh_msglen + sizeof (*sfp);
183 	sfp->ssf_error = error;
184 	sfp->ssf_assoc_id = 0;
185 
186 	bzero(&sfp->ssf_info, sizeof (sfp->ssf_info));
187 	sfp->ssf_info.sinfo_stream = smh->smh_sid;
188 	sfp->ssf_info.sinfo_flags = smh->smh_flags;
189 	sfp->ssf_info.sinfo_ppid = smh->smh_ppid;
190 	sfp->ssf_info.sinfo_context = smh->smh_context;
191 	sfp->ssf_info.sinfo_timetolive = TICK_TO_MSEC(smh->smh_ttl);
192 
193 	mp->b_wptr = (uchar_t *)(sfp + 1);
194 	mp->b_cont = msghdr->b_cont;
195 
196 	freeb(msghdr);
197 
198 	sctp_notify(sctp, mp, sfp->ssf_length);
199 
200 }
201 
202 /*
203  * Send failure when the message has been fully chunkified.
204  */
205 static void
206 sctp_sendfail_sent(sctp_t *sctp, mblk_t *meta, int error)
207 {
208 	mblk_t		*mp;
209 	mblk_t		*nmp;
210 	mblk_t		*tail;
211 	uint16_t	flags = SCTP_DATA_SENT;
212 
213 	if (!sctp->sctp_recvsendfailevnt) {
214 		sctp_free_msg(meta);
215 		return;
216 	}
217 
218 	/*
219 	 * We need to remove all data_hdr's.
220 	 */
221 	nmp = meta->b_cont;
222 	tail = meta;
223 	do {
224 		mp = nmp->b_next;
225 		nmp->b_next = NULL;
226 
227 		/*
228 		 * If one of the chunks hasn't been sent yet, say that
229 		 * the message hasn't been sent.
230 		 */
231 		if (!SCTP_CHUNK_ISSENT(nmp)) {
232 			flags = SCTP_DATA_UNSENT;
233 		}
234 		nmp->b_rptr += sizeof (sctp_data_hdr_t);
235 		if (nmp->b_rptr == nmp->b_wptr) {
236 			tail->b_cont = nmp->b_cont;
237 			freeb(nmp);
238 		} else {
239 			tail->b_cont = nmp;
240 		}
241 		while (tail->b_cont) {
242 			tail = tail->b_cont;
243 		}
244 	} while ((nmp = mp) != NULL);
245 
246 	sctp_sendfail(sctp, meta, flags, error);
247 }
248 
249 /*
250  * Send failure when the message hasn't been fully chunkified.
251  */
252 void
253 sctp_sendfail_event(sctp_t *sctp, mblk_t *meta, int error, boolean_t chunkified)
254 {
255 	mblk_t	*mp;
256 	mblk_t	*nmp;
257 	mblk_t	*tail;
258 
259 	if (meta == NULL)
260 		return;
261 
262 	if (!sctp->sctp_recvsendfailevnt) {
263 		sctp_free_msg(meta);
264 		return;
265 	}
266 
267 	/* If the message is fully chunkified */
268 	if (chunkified) {
269 		sctp_sendfail_sent(sctp, meta, error);
270 		return;
271 	}
272 	/*
273 	 * Message might be partially chunkified, we need to remove
274 	 * all data_hdr's.
275 	 */
276 	mp = meta->b_cont;
277 	tail = meta;
278 	while ((nmp = mp->b_next) != NULL) {
279 		mp->b_next = nmp->b_next;
280 		nmp->b_next = NULL;
281 		nmp->b_rptr += sizeof (sctp_data_hdr_t);
282 		if (nmp->b_rptr == nmp->b_wptr) {
283 			tail->b_cont = nmp->b_cont;
284 			freeb(nmp);
285 		} else {
286 			tail->b_cont = nmp;
287 		}
288 		while (tail->b_cont) {
289 			tail = tail->b_cont;
290 		}
291 	}
292 	tail->b_cont = mp;
293 
294 	sctp_sendfail(sctp, meta, SCTP_DATA_UNSENT, error);
295 }
296 
297 void
298 sctp_regift_xmitlist(sctp_t *sctp)
299 {
300 	mblk_t *mp;
301 
302 	if (!sctp->sctp_recvsendfailevnt) {
303 		return;
304 	}
305 
306 	while ((mp = sctp->sctp_xmit_head) != NULL) {
307 		sctp->sctp_xmit_head = mp->b_next;
308 		mp->b_next = NULL;
309 		if (sctp->sctp_xmit_head != NULL)
310 			sctp->sctp_xmit_head->b_prev = NULL;
311 		sctp_sendfail_event(sctp, mp, 0, B_TRUE);
312 	}
313 	while ((mp = sctp->sctp_xmit_unsent) != NULL) {
314 		sctp->sctp_xmit_unsent = mp->b_next;
315 		mp->b_next = NULL;
316 		sctp_sendfail_event(sctp, mp, 0, B_FALSE);
317 	}
318 	sctp->sctp_xmit_tail = sctp->sctp_xmit_unsent_tail = NULL;
319 	sctp->sctp_unacked = sctp->sctp_unsent = 0;
320 }
321 
322 void
323 sctp_intf_event(sctp_t *sctp, in6_addr_t addr, int state, int error)
324 {
325 	struct sctp_paddr_change *spc;
326 	ipaddr_t addr4;
327 	struct sockaddr_in *sin;
328 	struct sockaddr_in6 *sin6;
329 	mblk_t *mp;
330 
331 	if (!sctp->sctp_recvpathevnt) {
332 		return;
333 	}
334 
335 	if ((mp = allocb(sizeof (*spc), BPRI_MED)) == NULL) {
336 		return;
337 	}
338 
339 	spc = (struct sctp_paddr_change *)mp->b_rptr;
340 	spc->spc_type = SCTP_PEER_ADDR_CHANGE;
341 	spc->spc_flags = 0;
342 	spc->spc_length = sizeof (*spc);
343 	if (IN6_IS_ADDR_V4MAPPED(&addr)) {
344 		IN6_V4MAPPED_TO_IPADDR(&addr, addr4);
345 		sin = (struct sockaddr_in *)&spc->spc_aaddr;
346 		sin->sin_family = AF_INET;
347 		sin->sin_port = 0;
348 		sin->sin_addr.s_addr = addr4;
349 	} else {
350 		sin6 = (struct sockaddr_in6 *)&spc->spc_aaddr;
351 		sin6->sin6_family = AF_INET6;
352 		sin6->sin6_port = 0;
353 		sin6->sin6_addr = addr;
354 	}
355 	spc->spc_state = state;
356 	spc->spc_error = error;
357 	spc->spc_assoc_id = 0;
358 
359 	mp->b_wptr = (uchar_t *)(spc + 1);
360 	sctp_notify(sctp, mp, spc->spc_length);
361 }
362 
363 void
364 sctp_error_event(sctp_t *sctp, sctp_chunk_hdr_t *ch, boolean_t is_asconf)
365 {
366 	struct sctp_remote_error *sre;
367 	mblk_t *mp;
368 	size_t len;
369 	sctp_parm_hdr_t *errh = NULL;
370 	uint16_t dlen = 0;
371 	uint16_t error = 0;
372 	void *dtail = NULL;
373 
374 	if (!sctp->sctp_recvpeererr) {
375 		return;
376 	}
377 
378 	/*
379 	 * ASCONF PARM error chunks :
380 	 * PARM_ERROR_IND parm type is always followed by correlation id.
381 	 * See sctp_asconf_adderr() and sctp_asconf_prepend_errwrap() as to
382 	 * how these error chunks are build.
383 	 * error cause wrapper (PARM_ERROR_IND) + correlation id +
384 	 * error cause + error cause details.
385 	 *
386 	 * Regular error chunks :
387 	 * See sctp_make_err() as to how these error chunks are build.
388 	 * error chunk header (CHUNK_ERROR) + error cause + error cause details.
389 	 */
390 	if (is_asconf) {
391 		if (ntohs(ch->sch_len) >
392 		    (sizeof (*ch) + sizeof (uint32_t))) {
393 			errh = (sctp_parm_hdr_t *)((char *)ch +
394 			    sizeof (uint32_t) + sizeof (sctp_parm_hdr_t));
395 		}
396 	} else {
397 		if (ntohs(ch->sch_len) > sizeof (*ch)) {
398 			errh = (sctp_parm_hdr_t *)(ch + 1);
399 		}
400 	}
401 
402 	if (errh != NULL) {
403 		error = ntohs(errh->sph_type);
404 		dlen = ntohs(errh->sph_len) - sizeof (*errh);
405 		if (dlen > 0) {
406 			dtail = errh + 1;
407 		}
408 	}
409 
410 	len = sizeof (*sre) + dlen;
411 	if ((mp = allocb(len, BPRI_MED)) == NULL) {
412 		return;
413 	}
414 
415 	sre = (struct sctp_remote_error *)mp->b_rptr;
416 	sre->sre_type = SCTP_REMOTE_ERROR;
417 	sre->sre_flags = 0;
418 	sre->sre_length = len;
419 	sre->sre_assoc_id = 0;
420 	sre->sre_error = error;
421 	if (dtail != NULL) {
422 		bcopy(dtail, sre + 1, dlen);
423 	}
424 
425 	mp->b_wptr = mp->b_rptr + len;
426 	sctp_notify(sctp, mp, len);
427 }
428 
429 void
430 sctp_shutdown_event(sctp_t *sctp)
431 {
432 	struct sctp_shutdown_event *sse;
433 	mblk_t *mp;
434 
435 	if (!sctp->sctp_recvshutdownevnt) {
436 		return;
437 	}
438 
439 	if ((mp = allocb(sizeof (*sse), BPRI_MED)) == NULL) {
440 		return;
441 	}
442 
443 	sse = (struct sctp_shutdown_event *)mp->b_rptr;
444 	sse->sse_type = SCTP_SHUTDOWN_EVENT;
445 	sse->sse_flags = 0;
446 	sse->sse_length = sizeof (*sse);
447 	sse->sse_assoc_id = 0;
448 
449 	mp->b_wptr = (uchar_t *)(sse + 1);
450 	sctp_notify(sctp, mp, sse->sse_length);
451 }
452 
453 void
454 sctp_adaptation_event(sctp_t *sctp)
455 {
456 	struct sctp_adaptation_event *sai;
457 	mblk_t *mp;
458 
459 	if (!sctp->sctp_recvalevnt || !sctp->sctp_recv_adaptation) {
460 		return;
461 	}
462 	if ((mp = allocb(sizeof (*sai), BPRI_MED)) == NULL) {
463 		return;
464 	}
465 
466 	sai = (struct sctp_adaptation_event *)mp->b_rptr;
467 	sai->sai_type = SCTP_ADAPTATION_INDICATION;
468 	sai->sai_flags = 0;
469 	sai->sai_length = sizeof (*sai);
470 	sai->sai_assoc_id = 0;
471 	/*
472 	 * Adaptation code delivered in network byte order.
473 	 */
474 	sai->sai_adaptation_ind = sctp->sctp_rx_adaptation_code;
475 
476 	mp->b_wptr = (uchar_t *)(sai + 1);
477 	sctp_notify(sctp, mp, sai->sai_length);
478 
479 	sctp->sctp_recv_adaptation = 0; /* in case there's a restart later */
480 }
481 
482 /* Send partial deliver event */
483 void
484 sctp_partial_delivery_event(sctp_t *sctp)
485 {
486 	struct sctp_pdapi_event	*pdapi;
487 	mblk_t			*mp;
488 
489 	if (!sctp->sctp_recvpdevnt)
490 		return;
491 
492 	if ((mp = allocb(sizeof (*pdapi), BPRI_MED)) == NULL)
493 		return;
494 
495 	pdapi = (struct sctp_pdapi_event *)mp->b_rptr;
496 	pdapi->pdapi_type = SCTP_PARTIAL_DELIVERY_EVENT;
497 	pdapi->pdapi_flags = 0;
498 	pdapi->pdapi_length = sizeof (*pdapi);
499 	pdapi->pdapi_indication = SCTP_PARTIAL_DELIVERY_ABORTED;
500 	pdapi->pdapi_assoc_id = 0;
501 	mp->b_wptr = (uchar_t *)(pdapi + 1);
502 	sctp_notify(sctp, mp, pdapi->pdapi_length);
503 }
504