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 2006 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #pragma ident "%Z%%M% %I% %E% SMI"
28
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <sys/types.h>
32 #include <sys/socket.h>
33 #include <sys/sysmacros.h>
34 #include <inet/common.h>
35 #include <netinet/in.h>
36 #include <netinet/sctp.h>
37 #include <arpa/inet.h>
38 #include <string.h>
39 #include "snoop.h"
40
41 /*
42 * Snoop interpreter for SCTP (rfc2960).
43 *
44 * To add support for an upper-layer protocol, modify either
45 * the port-dispatcher in snoop_rport.c, or the protocol ID
46 * dispatcher at the bottom of this file (or both).
47 */
48
49 static void interpret_protoid(int, uint32_t, char *, int);
50 extern char *prot_prefix;
51
52 /*
53 * This defines the length of internal, unbounded buffers. We set
54 * this to be MAXLINE (the maximum verbose display line length) -
55 * 64, which should be enough for all necessary descriptions. 64
56 * bytes seems like a reasonably conservative estimate of the
57 * maximum prefix length snoop may add to any text buffer it hands out.
58 */
59 #define BUFLEN MAXLINE - 64
60
61 /*
62 * Common structure to hold descriptions and parsers for all
63 * chunks, parameters, and errors. Each parser should implement
64 * this interface:
65 *
66 * void parse(int flags, uint8_t cflags, void *data, int datalen);
67 *
68 * Where flags is the snoop flags, cflags are the chunk flags, data
69 * is the chunk or parameter data (not including the chunk or
70 * parameter header), and datalen is the length of the chunk or
71 * parameter data (again not including any headers).
72 */
73 typedef void parse_func_t(int, uint8_t, const void *, int);
74
75 typedef struct {
76 uint16_t id;
77 const char *sdesc; /* short description */
78 const char *vdesc; /* verbose description */
79 parse_func_t *parse; /* parser function */
80 } dispatch_t;
81
82 static void interpret_params(const void *, int, char *, const dispatch_t *,
83 int, int);
84
85 /*
86 * Chunk parsers
87 */
88 static parse_func_t parse_abort_chunk, parse_data_chunk, parse_error_chunk,
89 parse_init_chunk, parse_opaque_chunk, parse_sack_chunk,
90 parse_shutdone_chunk, parse_shutdown_chunk, parse_asconf_chunk,
91 parse_ftsn_chunk;
92
93
94 /*
95 * Chunk parser dispatch table. There are few enough chunks defined
96 * in the core protocol, and they are sequential, so the chunk code
97 * can be used as the index into this array for the common case.
98 * It is still necessary to check that the code and index match,
99 * since optional extensions will not follow sequentially the
100 * core chunks.
101 */
102 static const dispatch_t chunk_dispatch_table[] = {
103 /* code F_SUM desc F_DTAIL desc parser function */
104 { CHUNK_DATA, "Data", "Data Chunk",
105 parse_data_chunk },
106 { CHUNK_INIT, "Init", "Init Chunk",
107 parse_init_chunk },
108 { CHUNK_INIT_ACK, "Init ACK", "Init ACK Chunk",
109 parse_init_chunk },
110 { CHUNK_SACK, "SACK", "SACK Chunk",
111 parse_sack_chunk },
112 { CHUNK_HEARTBEAT, "Heartbeat", "Heartbeat Chunk",
113 parse_opaque_chunk },
114 { CHUNK_HEARTBEAT_ACK, "Heartbeat ACK", "Heartbeat ACK Chunk",
115 parse_opaque_chunk },
116 { CHUNK_ABORT, "Abort", "Abort Chunk",
117 parse_abort_chunk },
118 { CHUNK_SHUTDOWN, "Shutdown", "Shutdown Chunk",
119 parse_shutdown_chunk },
120 { CHUNK_SHUTDOWN_ACK, "Shutdown ACK", "Shutdown ACK Chunk",
121 NULL },
122 { CHUNK_ERROR, "Err", "Error Chunk",
123 parse_error_chunk },
124 { CHUNK_COOKIE, "Cookie", "Cookie Chunk",
125 parse_opaque_chunk },
126 { CHUNK_COOKIE_ACK, "Cookie ACK", "Cookie ACK Chunk",
127 parse_opaque_chunk },
128 { CHUNK_ECNE, "ECN Echo", "ECN Echo Chunk",
129 parse_opaque_chunk },
130 { CHUNK_CWR, "CWR", "CWR Chunk",
131 parse_opaque_chunk },
132 { CHUNK_SHUTDOWN_COMPLETE, "Shutdown Done", "Shutdown Done",
133 parse_shutdone_chunk },
134 { CHUNK_FORWARD_TSN, "FORWARD TSN", "Forward TSN Chunk",
135 parse_ftsn_chunk },
136 { CHUNK_ASCONF_ACK, "ASCONF ACK", "ASCONF ACK Chunk",
137 parse_asconf_chunk },
138 { CHUNK_ASCONF, "ASCONF", "ASCONF Chunk",
139 parse_asconf_chunk }
140 };
141
142 /*
143 * Parameter Parsers
144 */
145 static parse_func_t parse_encap_param, parse_int32_param, parse_ip4_param,
146 parse_ip6_param, parse_opaque_param, parse_suppaddr_param,
147 parse_unrec_chunk, parse_addip_param, parse_asconferr_param,
148 parse_asconfok_param, parse_addiperr_param;
149
150 /*
151 * Parameter parser dispatch table. The summary description is not
152 * used here. Strictly speaking, parameter types are defined within
153 * the context of a chunk type. However, thus far the IETF WG has
154 * agreed to follow the convention that parameter types are globally
155 * unique (and why not, with a 16-bit namespace). However, if this
156 * ever changes, there will need to be different parameter dispatch
157 * tables for each chunk type.
158 */
159 static const dispatch_t parm_dispatch_table[] = {
160 /* code F_SUM desc F_DTAIL desc parser function */
161 { PARM_UNKNOWN, "", "Unknown Parameter",
162 parse_opaque_param },
163 { PARM_HBINFO, "", "Heartbeat Info",
164 parse_opaque_param },
165 { PARM_ADDR4, "", "IPv4 Address",
166 parse_ip4_param },
167 { PARM_ADDR6, "", "IPv6 Address",
168 parse_ip6_param },
169 { PARM_COOKIE, "", "Cookie",
170 parse_opaque_param },
171 { PARM_UNRECOGNIZED, "", "Unrecognized Param",
172 parse_encap_param },
173 { PARM_COOKIE_PRESERVE, "", "Cookie Preservative",
174 parse_opaque_param },
175 { 10, "", "Reserved for ECN",
176 parse_opaque_param },
177 { PARM_ADDR_HOST_NAME, "", "Host Name Parameter",
178 parse_opaque_param },
179 { PARM_SUPP_ADDRS, "", "Supported Addresses",
180 parse_suppaddr_param },
181 { PARM_ECN_CAPABLE, "", "ECN Capable",
182 parse_opaque_param },
183 { PARM_ADD_IP, "", "Add IP",
184 parse_addip_param },
185 { PARM_DEL_IP, "", "Del IP",
186 parse_addip_param },
187 { PARM_ASCONF_ERROR, "", "ASCONF Error Ind",
188 parse_asconferr_param },
189 { PARM_PRIMARY_ADDR, "", "Set Primary Address",
190 parse_addip_param },
191 { PARM_FORWARD_TSN, "", "Forward TSN",
192 NULL },
193 { PARM_ASCONF_SUCCESS, "", "ASCONF Success Ind",
194 parse_asconfok_param }
195 };
196
197 /*
198 * Errors have the same wire format at parameters.
199 */
200 static const dispatch_t err_dispatch_table[] = {
201 /* code F_SUM desc F_DTAIL desc parser function */
202 { SCTP_ERR_UNKNOWN, "", "Unknown Error",
203 parse_opaque_param },
204 { SCTP_ERR_BAD_SID, "", "Invalid Stream ID",
205 parse_opaque_param },
206 { SCTP_ERR_MISSING_PARM, "", "Missing Parameter",
207 parse_opaque_param },
208 { SCTP_ERR_STALE_COOKIE, "", "Stale Cookie",
209 parse_int32_param },
210 { SCTP_ERR_NO_RESOURCES, "", "Out Of Resources",
211 parse_opaque_param },
212 { SCTP_ERR_BAD_ADDR, "", "Unresolvable Address",
213 parse_opaque_param },
214 { SCTP_ERR_UNREC_CHUNK, "", "Unrecognized Chunk",
215 parse_unrec_chunk },
216 { SCTP_ERR_BAD_MANDPARM, "", "Bad Mandatory Parameter",
217 parse_opaque_param },
218 { SCTP_ERR_UNREC_PARM, "", "Unrecognized Parameter",
219 parse_opaque_param },
220 { SCTP_ERR_NO_USR_DATA, "", "No User Data",
221 parse_int32_param },
222 { SCTP_ERR_COOKIE_SHUT, "", "Cookie During Shutdown",
223 parse_opaque_param },
224 { SCTP_ERR_DELETE_LASTADDR, "", "Delete Last Remaining Address",
225 parse_addiperr_param },
226 { SCTP_ERR_RESOURCE_SHORTAGE, "", "Resource Shortage",
227 parse_addiperr_param },
228 { SCTP_ERR_DELETE_SRCADDR, "", "Delete Source IP Address",
229 parse_addiperr_param },
230 { SCTP_ERR_AUTH_ERR, "", "Not authorized",
231 parse_addiperr_param }
232 };
233
234 /*
235 * These are global because the data chunk parser needs them to dispatch
236 * to ULPs. The alternative is to add source and dest port arguments
237 * to every parser, which seems even messier (since *only* the data
238 * chunk parser needs it)...
239 */
240 static in_port_t sport, dport;
241
242 /* Summary line miscellany */
243 static int sumlen;
244 static char scratch[MAXLINE];
245 static char *sumline;
246
247 #define SUMAPPEND(fmt) \
248 sumlen -= snprintf fmt; \
249 (void) strlcat(sumline, scratch, sumlen)
250
251 #define DUMPHEX_MAX 16
252
253 static const dispatch_t *
lookup_dispatch(int id,const dispatch_t * tbl,int tblsz)254 lookup_dispatch(int id, const dispatch_t *tbl, int tblsz)
255 {
256 int i;
257
258 /*
259 * Try fast lookup first. The common chunks defined in RFC2960
260 * will have indices aligned with their IDs, so this works for
261 * the common case.
262 */
263 if (id < (tblsz - 1)) {
264 if (id == tbl[id].id) {
265 return (tbl + id);
266 }
267 }
268
269 /*
270 * Nope - probably an extension. Search the whole table,
271 * starting from the end, since extensions are at the end.
272 */
273 for (i = tblsz - 1; i >= 0; i--) {
274 if (id == tbl[i].id) {
275 return (tbl + i);
276 }
277 }
278
279 return (NULL);
280 }
281
282 /*
283 * Dumps no more than the first DUMPHEX_MAX bytes in hex. If
284 * the user wants more, they can use the -x option to snoop.
285 */
286 static void
dumphex(const uchar_t * payload,int payload_len,char * msg)287 dumphex(const uchar_t *payload, int payload_len, char *msg)
288 {
289 int index;
290 int end;
291 char buf[BUFLEN];
292
293 if (payload_len == 0) {
294 return;
295 }
296
297 end = payload_len > DUMPHEX_MAX ? DUMPHEX_MAX : payload_len;
298
299 for (index = 0; index < end; index++) {
300 (void) snprintf(&buf[index * 3], 4, " %.2x", payload[index]);
301 }
302
303 if (payload_len > DUMPHEX_MAX) {
304 (void) strlcat(buf, " ...", BUFLEN);
305 }
306
307 (void) snprintf(get_line(0, 0), BUFLEN, msg, buf);
308 }
309
310 /*
311 * Present perscribed action for unknowns according to rfc2960. Works
312 * for chunks and parameters as well if the parameter type is
313 * shifted 8 bits right.
314 */
315 static const char *
get_action_desc(uint8_t id)316 get_action_desc(uint8_t id)
317 {
318 if ((id & 0xc0) == 0xc0) {
319 return (": skip on unknown, return error");
320 } else if ((id & 0x80) == 0x80) {
321 return (": skip on unknown, no error");
322 } else if ((id & 0x40) == 0x40) {
323 return (": stop on unknown, return error");
324 }
325
326 /* Top two bits are clear */
327 return (": stop on unknown, no error");
328 }
329
330 /* ARGSUSED */
331 static void
parse_asconfok_param(int flags,uint8_t notused,const void * data,int dlen)332 parse_asconfok_param(int flags, uint8_t notused, const void *data, int dlen)
333 {
334 uint32_t *cid;
335
336 if (dlen < sizeof (*cid)) {
337 (void) snprintf(get_line(0, 0), get_line_remain(),
338 " ==> Incomplete ASCONF Success Ind parameter");
339 return;
340 }
341 cid = (uint32_t *)data;
342 (void) snprintf(get_line(0, 0), get_line_remain(), " ASCONF CID = %u",
343 ntohl(*cid));
344 }
345
346 /* ARGSUSED */
347 static void
parse_asconferr_param(int flags,uint8_t notused,const void * data,int dlen)348 parse_asconferr_param(int flags, uint8_t notused, const void *data, int dlen)
349 {
350 uint32_t *cid;
351
352 if (dlen < sizeof (*cid)) {
353 (void) snprintf(get_line(0, 0), get_line_remain(),
354 " ==> Incomplete ASCONF Error Ind parameter");
355 return;
356 }
357 cid = (uint32_t *)data;
358 (void) snprintf(get_line(0, 0), get_line_remain(), " ASCONF CID = %u",
359 ntohl(*cid));
360
361 interpret_params(cid + 1, dlen - sizeof (*cid), "Error",
362 err_dispatch_table, A_CNT(err_dispatch_table), flags);
363 }
364
365 /* ARGSUSED */
366 static void
parse_addiperr_param(int flags,uint8_t notused,const void * data,int dlen)367 parse_addiperr_param(int flags, uint8_t notused, const void *data, int dlen)
368 {
369
370 interpret_params(data, dlen, "Parameter",
371 parm_dispatch_table, A_CNT(parm_dispatch_table), flags);
372 }
373
374 /* ARGSUSED */
375 static void
parse_addip_param(int flags,uint8_t notused,const void * data,int dlen)376 parse_addip_param(int flags, uint8_t notused, const void *data, int dlen)
377 {
378
379 uint32_t *cid;
380
381 if (dlen < sizeof (*cid)) {
382 (void) snprintf(get_line(0, 0), get_line_remain(),
383 " ==> Incomplete ASCONF Error Ind parameter");
384 return;
385 }
386 cid = (uint32_t *)data;
387 (void) snprintf(get_line(0, 0), get_line_remain(), " ASCONF CID = %u",
388 ntohl(*cid));
389
390 interpret_params(cid + 1, dlen - sizeof (*cid), "Parameter",
391 parm_dispatch_table, A_CNT(parm_dispatch_table), flags);
392 }
393
394 /* ARGSUSED */
395 static void
parse_ip4_param(int flags,uint8_t notused,const void * data,int datalen)396 parse_ip4_param(int flags, uint8_t notused, const void *data, int datalen)
397 {
398 char abuf[INET_ADDRSTRLEN];
399 char *ap;
400
401 if (datalen < sizeof (in_addr_t)) {
402 (void) snprintf(get_line(0, 0), get_line_remain(),
403 " ==> Incomplete IPv4 Addr parameter");
404 return;
405 }
406
407 ap = (char *)inet_ntop(AF_INET, data, abuf, INET_ADDRSTRLEN);
408 if (ap == NULL) {
409 ap = "<Bad Address>";
410 }
411
412 (void) snprintf(get_line(0, 0), get_line_remain(), " Addr = %s", ap);
413 }
414
415 /* ARGSUSED */
416 static void
parse_ip6_param(int flags,uint8_t notused,const void * data,int datalen)417 parse_ip6_param(int flags, uint8_t notused, const void *data, int datalen)
418 {
419 char abuf[INET6_ADDRSTRLEN];
420 char *ap;
421
422 if (datalen < sizeof (in6_addr_t)) {
423 (void) snprintf(get_line(0, 0), get_line_remain(),
424 " ==> Incomplete IPv6 Addr parameter");
425 return;
426 }
427
428 ap = (char *)inet_ntop(AF_INET6, data, abuf, INET6_ADDRSTRLEN);
429 if (ap == NULL) {
430 ap = "<Bad Address>";
431 }
432
433 (void) snprintf(get_line(0, 0), get_line_remain(), " Addr = %s", ap);
434 }
435
436 /* ARGSUSED */
437 static void
parse_int32_param(int flags,uint8_t notused,const void * data,int datalen)438 parse_int32_param(int flags, uint8_t notused, const void *data, int datalen)
439 {
440 if (datalen < 4) {
441 (void) snprintf(get_line(0, 0), get_line_remain(),
442 " ==> Incomplete INT32 parameter");
443 return;
444 }
445 (void) snprintf(get_line(0, 0), get_line_remain(), " INT32 = %u",
446 ntohl(*(uint32_t *)data));
447 }
448
449 /* ARGSUSED */
450 static void
parse_suppaddr_param(int flags,uint8_t notused,const void * data,int dlen)451 parse_suppaddr_param(int flags, uint8_t notused, const void *data, int dlen)
452 {
453 const uint16_t *type;
454
455 if (dlen < 2) {
456 (void) snprintf(get_line(0, 0), get_line_remain(),
457 "==> Incomplete Supported Addr parameter");
458 return;
459 }
460
461 type = data;
462 while (dlen > 0) {
463 switch (ntohs(*type)) {
464 case PARM_ADDR4:
465 (void) snprintf(get_line(0, 0), get_line_remain(),
466 " IPv4");
467 break;
468 case PARM_ADDR6:
469 (void) snprintf(get_line(0, 0), get_line_remain(),
470 " IPv6");
471 break;
472 case PARM_ADDR_HOST_NAME:
473 (void) snprintf(get_line(0, 0), get_line_remain(),
474 " Host Name");
475 break;
476 default:
477 (void) snprintf(get_line(0, 0), get_line_remain(),
478 "Unknown Type (%hu)", ntohs(*type));
479 break;
480 }
481 dlen -= sizeof (*type);
482 type++;
483 }
484 }
485
486 /*ARGSUSED*/
487 static void
parse_encap_param(int flags,uint8_t notused,const void * data,int dlen)488 parse_encap_param(int flags, uint8_t notused, const void *data, int dlen)
489 {
490 if (dlen < sizeof (sctp_parm_hdr_t)) {
491 (void) snprintf(get_line(0, 0), get_line_remain(),
492 "==> Incomplete Parameter");
493 return;
494 }
495
496 interpret_params(data, dlen, "Parameter",
497 parm_dispatch_table, A_CNT(parm_dispatch_table), flags);
498 }
499
500 /* ARGSUSED */
501 static void
parse_unrec_chunk(int flags,uint8_t cflags,const void * data,int datalen)502 parse_unrec_chunk(int flags, uint8_t cflags, const void *data, int datalen)
503 {
504 const sctp_chunk_hdr_t *cp = data;
505 const dispatch_t *dp;
506 const char *actstr;
507
508 if (datalen < sizeof (*cp)) {
509 (void) snprintf(get_line(0, 0), get_line_remain(),
510 "==> Incomplete Unrecognized Chunk Error");
511 return;
512 }
513
514 /* Maybe snoop knows about this chunk? */
515 dp = lookup_dispatch(cp->sch_id, chunk_dispatch_table,
516 A_CNT(chunk_dispatch_table));
517 if (dp != NULL) {
518 (void) snprintf(get_line(0, 0), get_line_remain(),
519 " Chunk Type = %u (%s)", cp->sch_id, dp->vdesc);
520 } else {
521 actstr = get_action_desc(cp->sch_id);
522 (void) snprintf(get_line(0, 0), get_line_remain(),
523 " Chunk Type = %u%s", cp->sch_id, actstr);
524 }
525 }
526
527 /*
528 * Same as parse_opaque_chunk except for the indentation.
529 */
530 /* ARGSUSED */
531 static void
parse_opaque_param(int flags,uint8_t cflags,const void * data,int datalen)532 parse_opaque_param(int flags, uint8_t cflags, const void *data, int datalen)
533 {
534 dumphex(data, datalen, " Data = %s");
535 }
536
537 /*
538 * Loops through all parameters (or errors) until it has read
539 * datalen bytes of information, finding a parser for each.
540 * The tbl argument allows the caller to specify which dispatch
541 * table to use, making this function useful for both parameters
542 * and errors. The type argument is used to denote whether this
543 * is an error or parameter in detailed mode.
544 */
545 static void
interpret_params(const void * data,int datalen,char * type,const dispatch_t * tbl,int tbl_size,int flags)546 interpret_params(const void *data, int datalen, char *type,
547 const dispatch_t *tbl, int tbl_size, int flags)
548 {
549 const sctp_parm_hdr_t *hdr = data;
550 uint16_t plen;
551 uint16_t ptype;
552 const char *desc;
553 parse_func_t *parse;
554 int pad;
555 const dispatch_t *dp;
556 const char *actstr;
557
558 for (;;) {
559 /*
560 * Adjust for padding: if the address isn't aligned, there
561 * should be some padding. So skip over the padding and
562 * adjust hdr accordingly. RFC2960 mandates that all
563 * parameters must be 32-bit aligned WRT the enclosing chunk,
564 * which ensures that this parameter header will
565 * be 32-bit aligned in memory. We must, of course, bounds
566 * check fraglen before actually trying to use hdr, in
567 * case the packet has been mangled or is the product
568 * of a buggy implementation.
569 */
570 if ((pad = (uintptr_t)hdr % SCTP_ALIGN) != 0) {
571 pad = SCTP_ALIGN - pad;
572 datalen -= pad;
573 /* LINTED pointer cast may result in improper alignment */
574 hdr = (sctp_parm_hdr_t *)((char *)hdr + pad);
575 }
576
577 /* Need to compare against 0 1st, since sizeof is unsigned */
578 if (datalen < 0 || datalen < sizeof (*hdr)) {
579 if (datalen > 0) {
580 (void) snprintf(get_line(0, 0),
581 get_line_remain(),
582 "==> Extra data after last parameter");
583 }
584 return;
585 }
586 plen = ntohs(hdr->sph_len);
587 if (datalen < plen || plen < sizeof (*hdr)) {
588 (void) snprintf(get_line(0, 0), get_line_remain(),
589 " ==> Incomplete %s", type);
590 return;
591 }
592
593 /* Get description and parser */
594 ptype = ntohs(hdr->sph_type);
595 desc = "Unknown Parameter Type";
596 parse = parse_opaque_param;
597 dp = lookup_dispatch(ptype, tbl, tbl_size);
598 if (dp != NULL) {
599 desc = dp->vdesc;
600 parse = dp->parse;
601 }
602
603 show_space();
604 if (dp != NULL) {
605 actstr = "";
606 } else {
607 actstr = get_action_desc((uint8_t)(ptype >> 8));
608 }
609 (void) snprintf(get_line(0, 0), get_line_remain(),
610 " ------- SCTP %s Type = %s (%u%s)", type, desc, ptype,
611 actstr);
612 (void) snprintf(get_line(0, 0), get_line_remain(),
613 " Data length = %hu", plen - sizeof (*hdr));
614
615 if (parse != NULL) {
616 parse(flags, 0, (char *)(hdr + 1),
617 plen - sizeof (*hdr));
618 }
619 datalen -= plen;
620 /* LINTED pointer cast may result in improper alignment */
621 hdr = (sctp_parm_hdr_t *)((char *)hdr + plen);
622 }
623 }
624
625 /* ARGSUSED */
626 static void
parse_ftsn_chunk(int flags,uint8_t cflags,const void * data,int datalen)627 parse_ftsn_chunk(int flags, uint8_t cflags, const void *data, int datalen)
628 {
629 uint32_t *ftsn;
630 ftsn_entry_t *ftsn_entry;
631
632 if (datalen < (sizeof (*ftsn) + sizeof (*ftsn_entry))) {
633 if (flags & F_DTAIL) {
634 (void) snprintf(get_line(0, 0), get_line_remain(),
635 "==> Incomplete FORWARD-TSN chunk");
636 }
637 return;
638 }
639
640 ftsn = (uint32_t *)data;
641 if (flags & F_SUM) {
642 SUMAPPEND((scratch, MAXLINE, "CTSN %x ", ntohl(*ftsn)));
643 return;
644 }
645 (void) snprintf(get_line(0, 0), get_line_remain(), "Cum TSN= %x",
646 ntohl(*ftsn));
647
648 datalen -= sizeof (*ftsn);
649 ftsn_entry = (ftsn_entry_t *)(ftsn + 1);
650 while (datalen >= sizeof (*ftsn_entry)) {
651 (void) snprintf(get_line(0, 0), get_line_remain(),
652 "SID = %u : SSN = %u", ntohs(ftsn_entry->ftsn_sid),
653 ntohs(ftsn_entry->ftsn_ssn));
654 datalen -= sizeof (*ftsn_entry);
655 ftsn_entry++;
656 }
657 }
658
659 /* ARGSUSED */
660 static void
parse_asconf_chunk(int flags,uint8_t cflags,const void * data,int datalen)661 parse_asconf_chunk(int flags, uint8_t cflags, const void *data, int datalen)
662 {
663 uint32_t *sn;
664
665 if (datalen < sizeof (*sn)) {
666 if (flags & F_DTAIL) {
667 (void) snprintf(get_line(0, 0), get_line_remain(),
668 "==> Incomplete ASCONF chunk");
669 }
670 return;
671 }
672
673 sn = (uint32_t *)data;
674 if (flags & F_SUM) {
675 SUMAPPEND((scratch, MAXLINE, "sn %x ", ntohl(*sn)));
676 return;
677 }
678 (void) snprintf(get_line(0, 0), get_line_remain(), "Serial Number= %x",
679 ntohl(*sn));
680 interpret_params(sn + 1, datalen - sizeof (*sn), "Parameter",
681 parm_dispatch_table, A_CNT(parm_dispatch_table), flags);
682 }
683
684 static void
parse_init_chunk(int flags,uint8_t cflags,const void * data,int datalen)685 parse_init_chunk(int flags, uint8_t cflags, const void *data, int datalen)
686 {
687 const sctp_init_chunk_t *icp = data;
688
689 if (datalen < sizeof (*icp)) {
690 if (flags & F_DTAIL) {
691 (void) snprintf(get_line(0, 0), get_line_remain(),
692 "==> Incomplete INIT chunk");
693 }
694 return;
695 }
696
697 if (flags & F_SUM) {
698 SUMAPPEND((scratch, MAXLINE, "tsn %x str %hu/%hu win %u ",
699 ntohl(icp->sic_inittsn), ntohs(icp->sic_outstr),
700 ntohs(icp->sic_instr), ntohl(icp->sic_a_rwnd)));
701 return;
702 }
703
704 (void) snprintf(get_line(0, 0), get_line_remain(), "Flags = 0x%.2x",
705 cflags);
706 (void) snprintf(get_line(0, 0), get_line_remain(),
707 "Initiate tag = 0x%.8x", ntohl(icp->sic_inittag));
708 (void) snprintf(get_line(0, 0), get_line_remain(),
709 "Advertised receiver window credit = %u", ntohl(icp->sic_a_rwnd));
710 (void) snprintf(get_line(0, 0), get_line_remain(),
711 "Outbound streams = %hu", ntohs(icp->sic_outstr));
712 (void) snprintf(get_line(0, 0), get_line_remain(),
713 "Inbound streams = %hu", ntohs(icp->sic_instr));
714 (void) snprintf(get_line(0, 0), get_line_remain(),
715 "Initial TSN = 0x%.8x", ntohl(icp->sic_inittsn));
716
717 if (datalen > sizeof (*icp)) {
718 interpret_params(icp + 1, datalen - sizeof (*icp),
719 "Parameter", parm_dispatch_table,
720 A_CNT(parm_dispatch_table), flags);
721 }
722 }
723
724 static void
parse_data_chunk(int flags,uint8_t cflags,const void * data,int datalen)725 parse_data_chunk(int flags, uint8_t cflags, const void *data, int datalen)
726 {
727 const sctp_data_chunk_t *dcp = data;
728 char *payload;
729 uint32_t ppid;
730
731 if (datalen < sizeof (*dcp)) {
732 if (flags & F_DTAIL) {
733 (void) snprintf(get_line(0, 0), get_line_remain(),
734 "==> Incomplete DATA chunk %d (%d)", datalen,
735 sizeof (*dcp));
736 }
737 return;
738 }
739
740 ppid = ntohl(dcp->sdc_payload_id);
741 /* This is the actual data len, excluding the data chunk header. */
742 datalen -= sizeof (*dcp);
743
744 if (flags & F_DTAIL) {
745 (void) snprintf(get_line(0, 0), get_line_remain(),
746 "flags = 0x%.2x", cflags);
747 (void) snprintf(get_line(0, 0), get_line_remain(), " %s",
748 getflag(cflags, SCTP_DATA_UBIT, "unordered", "ordered"));
749 (void) snprintf(get_line(0, 0), get_line_remain(), " %s",
750 getflag(cflags, SCTP_DATA_BBIT,
751 "beginning", "(beginning unset)"));
752 (void) snprintf(get_line(0, 0), get_line_remain(), " %s",
753 getflag(cflags, SCTP_DATA_EBIT, "end", "(end unset)"));
754 (void) snprintf(get_line(0, 0), get_line_remain(),
755 "TSN = 0x%.8x", ntohl(dcp->sdc_tsn));
756 (void) snprintf(get_line(0, 0), get_line_remain(),
757 "Stream ID = %hu", ntohs(dcp->sdc_sid));
758 (void) snprintf(get_line(0, 0), get_line_remain(),
759 "Stream Sequence Number = %hu", ntohs(dcp->sdc_ssn));
760 (void) snprintf(get_line(0, 0), get_line_remain(),
761 "Payload Protocol ID = 0x%.8x", ppid);
762 (void) snprintf(get_line(0, 0), get_line_remain(),
763 "Data Length = %d", datalen);
764 show_space();
765 }
766 if (flags & F_SUM) {
767 SUMAPPEND((scratch, MAXLINE, "len %d tsn %x str %hu/%hu "
768 "ppid %x ", datalen, ntohl(dcp->sdc_tsn),
769 ntohs(dcp->sdc_sid), ntohs(dcp->sdc_ssn), ppid));
770 }
771
772 /*
773 * Go to the next protocol layer, but not if we are in
774 * summary mode only. In summary mode, each ULP parse would
775 * create a new line, and if there were several data chunks
776 * bundled together in the packet, this would confuse snoop's
777 * packet numbering and timestamping.
778 *
779 * SCTP carries two ways to determine an ULP: ports and the
780 * payload protocol identifier (ppid). Since ports are the
781 * better entrenched convention, we first try interpret_reserved().
782 * If that fails to find a parser, we try by the PPID.
783 */
784 if (!(flags & F_ALLSUM) && !(flags & F_DTAIL)) {
785 return;
786 }
787
788 payload = (char *)(dcp + 1);
789 if (!interpret_reserved(flags, IPPROTO_SCTP, sport, dport, payload,
790 datalen) && ppid != 0) {
791
792 interpret_protoid(flags, ppid, payload, datalen);
793 }
794
795 /*
796 * Reset the protocol prefix, since it may have been changed
797 * by a ULP interpreter.
798 */
799 prot_prefix = "SCTP: ";
800 }
801
802 /* ARGSUSED */
803 static void
parse_sack_chunk(int flags,uint8_t cflags,const void * data,int datalen)804 parse_sack_chunk(int flags, uint8_t cflags, const void *data, int datalen)
805 {
806 const sctp_sack_chunk_t *scp = data;
807 uint16_t numfrags, numdups;
808 sctp_sack_frag_t *frag;
809 int i;
810 uint32_t *tsn;
811
812 if (datalen < sizeof (*scp)) {
813 if (flags & F_DTAIL) {
814 (void) snprintf(get_line(0, 0), get_line_remain(),
815 "==> Incomplete SACK chunk");
816 }
817 return;
818 }
819
820 if (flags & F_DTAIL) {
821 (void) snprintf(get_line(0, 0), get_line_remain(),
822 "Cumulative TSN ACK = 0x%.8x", ntohl(scp->ssc_cumtsn));
823 (void) snprintf(get_line(0, 0), get_line_remain(),
824 "Advertised Receiver Window Credit = %u",
825 ntohl(scp->ssc_a_rwnd));
826 numfrags = ntohs(scp->ssc_numfrags);
827 numdups = ntohs(scp->ssc_numdups);
828 (void) snprintf(get_line(0, 0), get_line_remain(),
829 "Number of Fragments = %hu", numfrags);
830 (void) snprintf(get_line(0, 0), get_line_remain(),
831 "Number of Duplicates = %hu", numdups);
832
833 /* Display any gap reports */
834 datalen -= sizeof (*scp);
835 if (datalen < (numfrags * sizeof (*frag))) {
836 (void) snprintf(get_line(0, 0), get_line_remain(),
837 " ==> Malformed gap report listing");
838 return;
839 }
840 frag = (sctp_sack_frag_t *)(scp + 1);
841 for (i = 0; i < numfrags; i++) {
842 (void) snprintf(get_line(0, 0), get_line_remain(),
843 " Fragment #%d: Start = %hu, end = %hu", i,
844 ntohs(frag->ssf_start), ntohs(frag->ssf_end));
845 frag += 1;
846 }
847
848 /* Display any duplicate reports */
849 datalen -= numfrags * sizeof (*frag);
850 if (datalen < (numdups * sizeof (*tsn))) {
851 (void) snprintf(get_line(0, 0), get_line_remain(),
852 " ==> Malformed duplicate report listing");
853 return;
854 }
855 /* LINTED pointer cast may result in improper alignment */
856 tsn = (uint32_t *)frag;
857 for (i = 0; i < numdups; i++) {
858 (void) snprintf(get_line(0, 0), get_line_remain(),
859 " Duplicate #%d: TSN = %x", i, *tsn);
860 tsn++;
861 }
862 }
863 if (flags & F_SUM) {
864 SUMAPPEND((scratch, MAXLINE,
865 "tsn %x win %u gaps/dups %hu/%hu ", ntohl(scp->ssc_cumtsn),
866 ntohl(scp->ssc_a_rwnd), ntohs(scp->ssc_numfrags),
867 ntohs(scp->ssc_numdups)));
868 }
869 }
870
871 /* ARGSUSED */
872 static void
parse_shutdown_chunk(int flags,uint8_t cflags,const void * data,int datalen)873 parse_shutdown_chunk(int flags, uint8_t cflags, const void *data, int datalen)
874 {
875 const uint32_t *cumtsn = data;
876
877 if (datalen < sizeof (*cumtsn)) {
878 if (flags & F_DTAIL) {
879 (void) snprintf(get_line(0, 0), get_line_remain(),
880 "==> Incomplete Shutdown chunk");
881 }
882 return;
883 }
884
885 if (flags & F_DTAIL) {
886 (void) snprintf(get_line(0, 0), get_line_remain(),
887 "Cumulative TSN = 0x%.8x", ntohl(*cumtsn));
888 }
889 if (flags & F_SUM) {
890 SUMAPPEND((scratch, MAXLINE, "tsn %x", ntohl(*cumtsn)));
891 }
892 }
893
894 /* ARGSUSED */
895 static void
parse_error_chunk(int flags,uint8_t cflags,const void * data,int datalen)896 parse_error_chunk(int flags, uint8_t cflags, const void *data, int datalen)
897 {
898 if (!(flags & F_DTAIL)) {
899 return;
900 }
901
902 interpret_params(data, datalen, "Error", err_dispatch_table,
903 A_CNT(err_dispatch_table), flags);
904 }
905
906 static void
parse_abort_chunk(int flags,uint8_t cflags,const void * data,int datalen)907 parse_abort_chunk(int flags, uint8_t cflags, const void *data, int datalen)
908 {
909 if (!(flags & F_DTAIL)) {
910 return;
911 }
912
913 (void) snprintf(get_line(0, 0), get_line_remain(), "flags = 0x%.2x",
914 cflags);
915 (void) snprintf(get_line(0, 0), get_line_remain(), " %s",
916 getflag(cflags, SCTP_TBIT, "TCB not destroyed", "TCB destroyed"));
917
918 interpret_params(data, datalen, "Error", err_dispatch_table,
919 A_CNT(err_dispatch_table), flags);
920 }
921
922 /* ARGSUSED2 */
923 static void
parse_shutdone_chunk(int flags,uint8_t cflags,const void * data,int datalen)924 parse_shutdone_chunk(int flags, uint8_t cflags, const void *data, int datalen)
925 {
926 if (!(flags & F_DTAIL)) {
927 return;
928 }
929
930 (void) snprintf(get_line(0, 0), get_line_remain(), "flags = 0x%.2x",
931 cflags);
932 (void) snprintf(get_line(0, 0), get_line_remain(), " %s",
933 getflag(cflags, SCTP_TBIT, "TCB not destroyed", "TCB destroyed"));
934 }
935
936 /* ARGSUSED */
937 static void
parse_opaque_chunk(int flags,uint8_t cflags,const void * data,int datalen)938 parse_opaque_chunk(int flags, uint8_t cflags, const void *data, int datalen)
939 {
940 if (!(flags & F_DTAIL)) {
941 return;
942 }
943 if (datalen == 0) {
944 return;
945 }
946
947 dumphex(data, datalen, "Data = %s");
948 }
949
950 /*
951 * Loops through all chunks until it has read fraglen bytes of
952 * information, finding a parser for each. If any parameters are
953 * present, interpret_params() is then called. Returns the remaining
954 * fraglen.
955 */
956 static int
interpret_chunks(int flags,sctp_chunk_hdr_t * cp,int fraglen)957 interpret_chunks(int flags, sctp_chunk_hdr_t *cp, int fraglen)
958 {
959 uint16_t clen;
960 int signed_len;
961 int pad;
962 const char *desc;
963 parse_func_t *parse;
964 const dispatch_t *dp;
965 const char *actstr;
966
967 for (;;) {
968 /*
969 * Adjust for padding: if the address isn't aligned, there
970 * should be some padding. So skip over the padding and
971 * adjust hdr accordingly. RFC2960 mandates that all
972 * chunks must be 32-bit aligned WRT the SCTP common hdr,
973 * which ensures that this chunk header will
974 * be 32-bit aligned in memory. We must, of course, bounds
975 * check fraglen before actually trying to use hdr, in
976 * case the packet has been mangled or is the product
977 * of a buggy implementation.
978 */
979 if ((pad = (uintptr_t)cp % SCTP_ALIGN) != 0) {
980 pad = SCTP_ALIGN - pad;
981 fraglen -= pad;
982 /* LINTED pointer cast may result in improper alignment */
983 cp = (sctp_chunk_hdr_t *)((char *)cp + pad);
984 }
985
986 /* Need to compare against 0 1st, since sizeof is unsigned */
987 if (fraglen < 0 || fraglen < sizeof (*cp)) {
988 if (fraglen > 0 && flags & F_DTAIL) {
989 (void) snprintf(get_line(0, 0),
990 get_line_remain(),
991 "==> Extra data after last chunk");
992 }
993 return (fraglen);
994 }
995
996 clen = ntohs(cp->sch_len);
997 if (fraglen < clen) {
998 if (flags & F_DTAIL) {
999 (void) snprintf(get_line(0, 0),
1000 get_line_remain(), "==> Corrupted chunk");
1001 }
1002 return (fraglen);
1003 }
1004
1005 signed_len = clen - sizeof (*cp);
1006 if (signed_len < 0) {
1007 if (flags & F_DTAIL) {
1008 (void) snprintf(get_line(0, 0),
1009 get_line_remain(),
1010 "==> Incomplete or corrupted chunk");
1011 }
1012 return (0);
1013 }
1014
1015 /* Get description and parser */
1016 dp = lookup_dispatch(cp->sch_id, chunk_dispatch_table,
1017 A_CNT(chunk_dispatch_table));
1018 if (dp != NULL) {
1019 if (flags & F_SUM) {
1020 desc = dp->sdesc;
1021 } else if (flags & F_DTAIL) {
1022 desc = dp->vdesc;
1023 }
1024 parse = dp->parse;
1025 } else {
1026 if (flags & F_SUM) {
1027 desc = "UNK";
1028 } else if (flags & F_DTAIL) {
1029 desc = "Unknown Chunk Type";
1030 }
1031 parse = parse_opaque_chunk;
1032 }
1033
1034 if (flags & F_SUM) {
1035 SUMAPPEND((scratch, MAXLINE, "%s ", desc));
1036 }
1037 if (flags & F_DTAIL) {
1038 show_space();
1039
1040 if (dp != NULL) {
1041 actstr = "";
1042 } else {
1043 actstr = get_action_desc(cp->sch_id);
1044 }
1045 (void) snprintf(get_line(0, 0), get_line_remain(),
1046 "------- SCTP Chunk Type = %s (%u%s)", desc,
1047 cp->sch_id, actstr);
1048
1049 (void) snprintf(get_line(0, 0), get_line_remain(),
1050 "Chunk length = %hu", clen);
1051 }
1052
1053 if (parse != NULL) {
1054 parse(flags, cp->sch_flags, (char *)(cp + 1),
1055 signed_len);
1056 }
1057
1058 fraglen -= clen;
1059
1060 /* LINTED pointer cast may result in improper alignment */
1061 cp = (sctp_chunk_hdr_t *)((char *)cp + clen);
1062 }
1063 }
1064
1065 void
interpret_sctp(int flags,sctp_hdr_t * sctp,int iplen,int fraglen)1066 interpret_sctp(int flags, sctp_hdr_t *sctp, int iplen, int fraglen)
1067 {
1068 int len_from_iphdr;
1069 sctp_chunk_hdr_t *cp;
1070 char *pn;
1071 char buff[32];
1072
1073 /*
1074 * Alignment check. If the header is 32-bit aligned, all other
1075 * protocol units will also be aligned, as mandated by rfc2960.
1076 * Buggy packets will be caught and flagged by chunk and
1077 * parameter bounds checking.
1078 * If the header is not aligned, however, we drop the packet.
1079 */
1080 if (!IS_P2ALIGNED(sctp, SCTP_ALIGN)) {
1081 if (flags & F_DTAIL) {
1082 (void) snprintf(get_line(0, 0), get_line_remain(),
1083 "==> SCTP header not aligned, dropping");
1084 }
1085 return;
1086 }
1087
1088 fraglen -= sizeof (*sctp);
1089 if (fraglen < 0) {
1090 if (flags & F_DTAIL) {
1091 (void) snprintf(get_line(0, 0), get_line_remain(),
1092 "==> Incomplete sctp header");
1093 }
1094 return;
1095 }
1096 /* If fraglen is somehow longer than the IP payload, adjust it */
1097 len_from_iphdr = iplen - sizeof (*sctp);
1098 if (fraglen > len_from_iphdr) {
1099 fraglen = len_from_iphdr;
1100 }
1101
1102 /* Keep track of the ports */
1103 sport = ntohs(sctp->sh_sport);
1104 dport = ntohs(sctp->sh_dport);
1105
1106 /* Set pointer to first chunk */
1107 cp = (sctp_chunk_hdr_t *)(sctp + 1);
1108
1109 if (flags & F_SUM) {
1110 sumline = get_sum_line();
1111 *sumline = '\0';
1112 sumlen = MAXLINE;
1113
1114 SUMAPPEND((scratch, MAXLINE, "SCTP D=%d S=%d ", dport, sport));
1115 }
1116
1117 if (flags & F_DTAIL) {
1118 show_header("SCTP: ", "SCTP Header", fraglen);
1119 show_space();
1120
1121 pn = getportname(IPPROTO_SCTP, (ushort_t)sport);
1122 if (pn == NULL) {
1123 pn = "";
1124 } else {
1125 (void) snprintf(buff, sizeof (buff), "(%s)", pn);
1126 pn = buff;
1127 }
1128 (void) snprintf(get_line(0, 0), get_line_remain(),
1129 "Source port = %hu %s", sport, pn);
1130
1131 pn = getportname(IPPROTO_SCTP, (ushort_t)dport);
1132 if (pn == NULL) {
1133 pn = "";
1134 } else {
1135 (void) snprintf(buff, sizeof (buff), "(%s)", pn);
1136 pn = buff;
1137 }
1138 (void) snprintf(get_line(0, 0), get_line_remain(),
1139 "Destination port = %hu %s", dport, pn);
1140 (void) snprintf(get_line(0, 0), get_line_remain(),
1141 "Verification tag = 0x%.8x", ntohl(sctp->sh_verf));
1142 (void) snprintf(get_line(0, 0), get_line_remain(),
1143 "CRC-32c = 0x%.8x", ntohl(sctp->sh_chksum));
1144 }
1145
1146 (void) interpret_chunks(flags, cp, fraglen);
1147
1148 if (flags & F_DTAIL) {
1149 show_space();
1150 }
1151 }
1152
1153 /*
1154 * Payload protocol ID table. Add new ULP information and parsers
1155 * here.
1156 */
1157
1158 struct protoid_table {
1159 int pid_num;
1160 char *pid_short;
1161 char *pid_long;
1162 };
1163
1164 static struct protoid_table pid_sctp[] = {
1165 1, "IUA", "ISDN Q.921 User Adaption Layer",
1166 2, "M2UA", "SS7 MTP2 User Adaption Layer",
1167 3, "M3UA", "SS7 MTP3 User Adaption Layer",
1168 4, "SUA", "SS7 SCCP User Adaption Layer",
1169 5, "M2PA", "SS7 MTP2-User Peer-to-Peer Adaption Layer",
1170 6, "V5UA", "V5UA",
1171 0, NULL, "",
1172 };
1173
1174 static void
interpret_protoid(int flags,uint32_t ppid,char * data,int dlen)1175 interpret_protoid(int flags, uint32_t ppid, char *data, int dlen)
1176 {
1177 struct protoid_table *p;
1178 char pbuf[16];
1179
1180 /*
1181 * Branch to a ULP interpreter here, or continue on to
1182 * the default parser, which just tries to display
1183 * printable characters from the payload.
1184 */
1185
1186 for (p = pid_sctp; p->pid_num; p++) {
1187 if (ppid == p->pid_num) {
1188 if (flags & F_SUM) {
1189 (void) snprintf(get_sum_line(), MAXLINE,
1190 "D=%d S=%d %s %s", dport, sport,
1191 p->pid_short, show_string(data, dlen, 20));
1192 }
1193
1194 if (flags & F_DTAIL) {
1195 (void) snprintf(pbuf, MAXLINE, "%s: ",
1196 p->pid_short);
1197 show_header(pbuf, p->pid_long, dlen);
1198 show_space();
1199 (void) snprintf(get_line(0, 0),
1200 get_line_remain(), "\"%s\"",
1201 show_string(data, dlen, 60));
1202 show_trailer();
1203 }
1204
1205 return;
1206 }
1207 }
1208 }
1209