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 /*
23 * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
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/strsubr.h>
31
32 #include <netinet/in.h>
33 #include <netinet/ip6.h>
34
35 #include <inet/common.h>
36 #include <inet/ip.h>
37 #include <inet/mib2.h>
38 #include <inet/ipclassifier.h>
39 #include "sctp_impl.h"
40
41 void
sctp_return_heartbeat(sctp_t * sctp,sctp_chunk_hdr_t * hbcp,mblk_t * mp)42 sctp_return_heartbeat(sctp_t *sctp, sctp_chunk_hdr_t *hbcp, mblk_t *mp)
43 {
44 mblk_t *smp;
45 sctp_chunk_hdr_t *cp;
46 ipha_t *iniph;
47 ip6_t *inip6h;
48 int isv4;
49 in6_addr_t addr;
50 sctp_faddr_t *fp;
51 uint16_t len;
52 sctp_stack_t *sctps = sctp->sctp_sctps;
53
54 BUMP_LOCAL(sctp->sctp_ibchunks);
55
56 /* Update the faddr for the src addr */
57 isv4 = (IPH_HDR_VERSION(mp->b_rptr) == IPV4_VERSION);
58 if (isv4) {
59 iniph = (ipha_t *)mp->b_rptr;
60 IN6_IPADDR_TO_V4MAPPED(iniph->ipha_src, &addr);
61 } else {
62 inip6h = (ip6_t *)mp->b_rptr;
63 addr = inip6h->ip6_src;
64 }
65 fp = sctp_lookup_faddr(sctp, &addr);
66 /* If the source address is bogus we silently drop the packet */
67 if (fp == NULL) {
68 dprint(1,
69 ("sctp_return_heartbeat: %p bogus hb from %x:%x:%x:%x\n",
70 (void *)sctp, SCTP_PRINTADDR(addr)));
71 SCTP_KSTAT(sctps, sctp_return_hb_failed);
72 return;
73 }
74 dprint(3, ("sctp_return_heartbeat: %p got hb from %x:%x:%x:%x\n",
75 (void *)sctp, SCTP_PRINTADDR(addr)));
76
77 /*
78 * XXX It's really tempting to reuse the heartbeat mblk. But
79 * this complicates processing in sctp_dispatch (i.e. it will
80 * screw up sctp_next_chunk since we will set the chunk
81 * header's length into network byte-order), and if we ever
82 * encounter a heartbeat bundled with other chunks...
83 * So we take the slower-but-safe route.
84 */
85 len = ntohs(hbcp->sch_len);
86
87 /* Create an IP header, returning to the src addr from the heartbt */
88 smp = sctp_make_mp(sctp, fp, len);
89 if (smp == NULL) {
90 SCTP_KSTAT(sctps, sctp_return_hb_failed);
91 return;
92 }
93
94 cp = (sctp_chunk_hdr_t *)smp->b_wptr;
95 cp->sch_id = CHUNK_HEARTBEAT_ACK;
96 cp->sch_flags = 0;
97 cp->sch_len = htons(len);
98
99 /* Copy the information field from the heartbeat */
100 bcopy((void *)(hbcp + 1), (void *)(cp + 1), len - sizeof (*cp));
101
102 smp->b_wptr += len;
103
104 BUMP_LOCAL(sctp->sctp_obchunks);
105
106 sctp_set_iplen(sctp, smp, fp->sf_ixa);
107 (void) conn_ip_output(smp, fp->sf_ixa);
108 BUMP_LOCAL(sctp->sctp_opkts);
109 }
110
111 /*
112 * The data section of the heartbeat contains a time field (lbolt64),
113 * a 64 bit secret, followed by the v6 (possible a v4mapped) address this
114 * heartbeat was sent to. No byte-ordering is done, since the heartbeat
115 * is not interpreted by the peer.
116 */
117 void
sctp_send_heartbeat(sctp_t * sctp,sctp_faddr_t * fp)118 sctp_send_heartbeat(sctp_t *sctp, sctp_faddr_t *fp)
119 {
120 sctp_chunk_hdr_t *cp;
121 sctp_parm_hdr_t *hpp;
122 int64_t *t;
123 int64_t now;
124 in6_addr_t *a;
125 mblk_t *hbmp;
126 size_t hblen;
127 sctp_stack_t *sctps = sctp->sctp_sctps;
128
129 dprint(3, ("sctp_send_heartbeat: to %x:%x:%x:%x from %x:%x:%x:%x\n",
130 SCTP_PRINTADDR(fp->sf_faddr), SCTP_PRINTADDR(fp->sf_saddr)));
131
132 hblen = sizeof (*cp) +
133 sizeof (*hpp) +
134 sizeof (*t) +
135 sizeof (fp->sf_hb_secret) +
136 sizeof (fp->sf_faddr);
137 hbmp = sctp_make_mp(sctp, fp, hblen);
138 if (hbmp == NULL) {
139 SCTP_KSTAT(sctps, sctp_send_hb_failed);
140 return;
141 }
142
143 cp = (sctp_chunk_hdr_t *)hbmp->b_wptr;
144 cp->sch_id = CHUNK_HEARTBEAT;
145 cp->sch_flags = 0;
146 cp->sch_len = hblen;
147 cp->sch_len = htons(cp->sch_len);
148
149 hpp = (sctp_parm_hdr_t *)(cp + 1);
150 hpp->sph_type = htons(PARM_HBINFO);
151 hpp->sph_len = hblen - sizeof (*cp);
152 hpp->sph_len = htons(hpp->sph_len);
153
154 /*
155 * Timestamp
156 *
157 * Copy the current time to the heartbeat and we can use it to
158 * calculate the RTT when we get it back in the heartbeat ACK.
159 */
160 now = ddi_get_lbolt64();
161 t = (int64_t *)(hpp + 1);
162 bcopy(&now, t, sizeof (now));
163
164 /*
165 * Secret
166 *
167 * The per peer address secret is used to make sure that the heartbeat
168 * ack is really in response to our heartbeat. This prevents blind
169 * spoofing of heartbeat ack to fake the validity of an address.
170 */
171 t++;
172 bcopy(&fp->sf_hb_secret, t, sizeof (uint64_t));
173
174 /*
175 * Peer address
176 *
177 * The peer address is used to associate the heartbeat ack with
178 * the correct peer address. The reason is that the peer is
179 * multihomed so that it may not use the same address as source
180 * in response to our heartbeat.
181 */
182 a = (in6_addr_t *)(t + 1);
183 bcopy(&fp->sf_faddr, a, sizeof (*a));
184
185 hbmp->b_wptr += hblen;
186
187 /* Update the faddr's info */
188 fp->sf_lastactive = now;
189 fp->sf_hb_pending = B_TRUE;
190
191 BUMP_LOCAL(sctp->sctp_obchunks);
192 SCTPS_BUMP_MIB(sctps, sctpTimHeartBeatProbe);
193
194 sctp_set_iplen(sctp, hbmp, fp->sf_ixa);
195 (void) conn_ip_output(hbmp, fp->sf_ixa);
196 BUMP_LOCAL(sctp->sctp_opkts);
197 }
198
199 /*
200 * Call right after any address change to validate peer addresses.
201 */
202 void
sctp_validate_peer(sctp_t * sctp)203 sctp_validate_peer(sctp_t *sctp)
204 {
205 sctp_faddr_t *fp;
206 int cnt;
207 int64_t now;
208 int64_t earliest_expiry;
209 sctp_stack_t *sctps = sctp->sctp_sctps;
210
211 now = ddi_get_lbolt64();
212 earliest_expiry = 0;
213 cnt = sctps->sctps_maxburst;
214
215 /*
216 * Loop thru the list looking for unconfirmed addresses and
217 * send a heartbeat. But we should only send at most sctp_maxburst
218 * heartbeats.
219 */
220 for (fp = sctp->sctp_faddrs; fp != NULL; fp = fp->sf_next) {
221 /* No need to validate unreachable address. */
222 if (fp->sf_state == SCTP_FADDRS_UNREACH)
223 continue;
224 if (fp->sf_state == SCTP_FADDRS_UNCONFIRMED) {
225 if (cnt-- > 0) {
226 fp->sf_hb_expiry = now + fp->sf_rto;
227 sctp_send_heartbeat(sctp, fp);
228 } else {
229 /*
230 * If we cannot send now, be more aggressive
231 * and try again about half of RTO. Note that
232 * all the unsent probes are set to expire at
233 * the same time.
234 */
235 fp->sf_hb_expiry = now +
236 (sctp->sctp_rto_initial >> 1);
237 }
238 }
239 /* Find the earliest heartbeat expiry time for ALL fps. */
240 if (fp->sf_hb_interval != 0 && (earliest_expiry == 0 ||
241 fp->sf_hb_expiry < earliest_expiry)) {
242 earliest_expiry = fp->sf_hb_expiry;
243 }
244 }
245 /* We use heartbeat timer for autoclose. */
246 if (sctp->sctp_autoclose != 0) {
247 int64_t expire;
248
249 expire = sctp->sctp_active + sctp->sctp_autoclose;
250 if (earliest_expiry == 0 || expire < earliest_expiry)
251 earliest_expiry = expire;
252 }
253
254 /*
255 * Set the timer to fire for the earliest heartbeat unless
256 * heartbeat is disabled for all addresses.
257 */
258 if (earliest_expiry != 0) {
259 earliest_expiry -= now;
260 if (earliest_expiry < 0)
261 earliest_expiry = 1;
262 sctp_timer(sctp, sctp->sctp_heartbeat_mp, earliest_expiry);
263 }
264 }
265
266 /*
267 * Process an incoming heartbeat ack. When sending a heartbeat, we
268 * put the timestamp, a secret and the peer address the heartbeat is
269 * sent in the data part of the heartbeat. We will extract this info
270 * and verify that this heartbeat ack is valid.
271 */
272 void
sctp_process_heartbeat(sctp_t * sctp,sctp_chunk_hdr_t * cp)273 sctp_process_heartbeat(sctp_t *sctp, sctp_chunk_hdr_t *cp)
274 {
275 int64_t *sentp, sent;
276 uint64_t secret;
277 in6_addr_t addr;
278 sctp_faddr_t *fp;
279 sctp_parm_hdr_t *hpp;
280 int64_t now;
281
282 BUMP_LOCAL(sctp->sctp_ibchunks);
283
284 /* Sanity checks */
285 ASSERT(OK_32PTR(cp));
286 if (ntohs(cp->sch_len) < (sizeof (*cp) + sizeof (*hpp) +
287 sizeof (sent) + sizeof (secret) + sizeof (addr))) {
288 /* drop it */
289 dprint(2, ("sctp_process_heartbeat: malformed ack %p\n",
290 (void *)sctp));
291 return;
292 }
293
294 hpp = (sctp_parm_hdr_t *)(cp + 1);
295 if (ntohs(hpp->sph_type) != PARM_HBINFO ||
296 ntohs(hpp->sph_len) != (ntohs(cp->sch_len) - sizeof (*cp))) {
297 dprint(2,
298 ("sctp_process_heartbeat: malformed param in ack %p\n",
299 (void *)sctp));
300 return;
301 }
302
303 /*
304 * Pull out the time sent from the ack.
305 * SCTP is 32-bit aligned, so copy 64 bit quantity. Since we
306 * put it in, it should be in our byte order.
307 */
308 sentp = (int64_t *)(hpp + 1);
309 bcopy(sentp, &sent, sizeof (sent));
310
311 /* Grab the secret to make sure that this heartbeat is valid */
312 bcopy(++sentp, &secret, sizeof (secret));
313
314 /* Next, verify the address to make sure that it is the right one. */
315 bcopy(++sentp, &addr, sizeof (addr));
316 fp = sctp_lookup_faddr(sctp, &addr);
317 if (fp == NULL) {
318 dprint(2, ("sctp_process_heartbeat: invalid faddr (sctp=%p)\n",
319 (void *)sctp));
320 return;
321 }
322 if (secret != fp->sf_hb_secret) {
323 dprint(2,
324 ("sctp_process_heartbeat: invalid secret in ack %p\n",
325 (void *)sctp));
326 return;
327 }
328
329 /* This address is now confirmed and alive. */
330 sctp_faddr_alive(sctp, fp);
331 now = ddi_get_lbolt64();
332 sctp_update_rtt(sctp, fp, now - sent);
333
334 /*
335 * Note that the heartbeat timer should still be running, we don't
336 * reset it to avoid going through the whole list of peer addresses
337 * for each heartbeat ack as we probably are in interrupt context.
338 */
339 fp->sf_hb_expiry = now + SET_HB_INTVL(fp);
340 }
341