Add tcpdump and libpcap.

- Update the file builder generator to handle generator specific cflags and
  includes. The tcpdump and libpcap have localised headers and need specific
  headers paths to see them. There are also module specific flags and these
  need to be passed to the lex and yacc generators.

- Add the tcpdump support.

1 files changed, 409 insertions, 0 deletions

diff --git a/freebsd/contrib/tcpdump/print-sctp.c b/freebsd/contrib/tcpdump/print-sctp.c
new file mode 100644
index 00000000..afd3f7d2
--- /dev/null
+++ b/freebsd/contrib/tcpdump/print-sctp.c
@@ -0,0 +1,409 @@
+#include <machine/rtems-bsd-user-space.h>
+
+/* Copyright (c) 2001 NETLAB, Temple University
+ * Copyright (c) 2001 Protocol Engineering Lab, University of Delaware
+ *
+ * Jerry Heinz <gheinz@astro.temple.edu>
+ * John Fiore <jfiore@joda.cis.temple.edu>
+ * Armando L. Caro Jr. <acaro@cis.udel.edu>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the University nor of the Laboratory may be used
+ *    to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifndef lint
+static const char rcsid[] _U_ =
+"@(#) $Header: /tcpdump/master/tcpdump/print-sctp.c,v 1.21 2007-09-13 18:03:49 guy Exp $ (NETLAB/PEL)";
+#endif
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <tcpdump-stdinc.h>
+
+#include "sctpHeader.h"
+#include "sctpConstants.h"
+#include <assert.h>
+
+#include <stdio.h>
+#include <string.h>
+
+#include "interface.h"
+#include "addrtoname.h"
+#include "extract.h"			/* must come after interface.h */
+#include "ip.h"
+#ifdef INET6
+#include "ip6.h"
+#endif
+
+#define CHAN_HP 6704
+#define CHAN_MP 6705
+#define CHAN_LP 6706
+
+struct tok ForCES_channels[] = {
+	{ CHAN_HP, "ForCES HP" },
+	{ CHAN_MP, "ForCES MP" },
+	{ CHAN_LP, "ForCES LP" },
+	{ 0, NULL }
+};
+
+static inline int isForCES_port(u_short Port)
+{
+	if (Port == CHAN_HP)
+		return 1;
+	if (Port == CHAN_MP)
+		return 1;
+	if (Port == CHAN_LP)
+		return 1;
+
+	return 0;
+}
+
+void sctp_print(const u_char *bp,        /* beginning of sctp packet */
+		const u_char *bp2,       /* beginning of enclosing */
+		u_int sctpPacketLength)  /* ip packet */
+{
+  const struct sctpHeader *sctpPktHdr;
+  const struct ip *ip;
+#ifdef INET6
+  const struct ip6_hdr *ip6;
+#endif
+  const void *endPacketPtr;
+  u_short sourcePort, destPort;
+  int chunkCount;
+  const struct sctpChunkDesc *chunkDescPtr;
+  const void *nextChunk;
+  const char *sep;
+  int isforces = 0;
+
+
+  sctpPktHdr = (const struct sctpHeader*) bp;
+  endPacketPtr = (const u_char*)sctpPktHdr+sctpPacketLength;
+
+  if( (u_long) endPacketPtr > (u_long) snapend)
+    endPacketPtr = (const void *) snapend;
+  ip = (struct ip *)bp2;
+#ifdef INET6
+  if (IP_V(ip) == 6)
+    ip6 = (const struct ip6_hdr *)bp2;
+  else
+    ip6 = NULL;
+#endif /*INET6*/
+  TCHECK(*sctpPktHdr);
+
+  if (sctpPacketLength < sizeof(struct sctpHeader))
+    {
+      (void)printf("truncated-sctp - %ld bytes missing!",
+		   (long)sctpPacketLength-sizeof(struct sctpHeader));
+      return;
+    }
+
+  /*    sctpPacketLength -= sizeof(struct sctpHeader);  packet length  */
+  /*  			      is now only as long as the payload  */
+
+  sourcePort = EXTRACT_16BITS(&sctpPktHdr->source);
+  destPort = EXTRACT_16BITS(&sctpPktHdr->destination);
+
+#ifdef INET6
+  if (ip6) {
+    (void)printf("%s.%d > %s.%d: sctp",
+      ip6addr_string(&ip6->ip6_src),
+      sourcePort,
+      ip6addr_string(&ip6->ip6_dst),
+      destPort);
+  } else
+#endif /*INET6*/
+  {
+    (void)printf("%s.%d > %s.%d: sctp",
+      ipaddr_string(&ip->ip_src),
+      sourcePort,
+      ipaddr_string(&ip->ip_dst),
+      destPort);
+  }
+  fflush(stdout);
+
+  if (isForCES_port(sourcePort)) {
+         printf("[%s]", tok2str(ForCES_channels, NULL, sourcePort));
+         isforces = 1;
+  }
+  if (isForCES_port(destPort)) {
+         printf("[%s]", tok2str(ForCES_channels, NULL, destPort));
+         isforces = 1;
+  }
+
+  if (vflag >= 2)
+    sep = "\n\t";
+  else
+    sep = " (";
+  /* cycle through all chunks, printing information on each one */
+  for (chunkCount = 0,
+	 chunkDescPtr = (const struct sctpChunkDesc *)
+	    ((const u_char*) sctpPktHdr + sizeof(struct sctpHeader));
+       chunkDescPtr != NULL &&
+	 ( (const void *)
+	    ((const u_char *) chunkDescPtr + sizeof(struct sctpChunkDesc))
+	   <= endPacketPtr);
+
+       chunkDescPtr = (const struct sctpChunkDesc *) nextChunk, chunkCount++)
+    {
+      u_int16_t chunkLength;
+      const u_char *chunkEnd;
+      u_int16_t align;
+
+      TCHECK(*chunkDescPtr);
+      chunkLength = EXTRACT_16BITS(&chunkDescPtr->chunkLength);
+      if (chunkLength < sizeof(*chunkDescPtr)) {
+      	printf("%s%d) [Bad chunk length %u]", sep, chunkCount+1, chunkLength);
+      	break;
+      }
+
+      TCHECK2(*((u_int8_t *)chunkDescPtr), chunkLength);
+      chunkEnd = ((const u_char*)chunkDescPtr + chunkLength);
+
+      align=chunkLength % 4;
+      if (align != 0)
+	align = 4 - align;
+
+      nextChunk = (const void *) (chunkEnd + align);
+
+      printf("%s%d) ", sep, chunkCount+1);
+      switch (chunkDescPtr->chunkID)
+	{
+	case SCTP_DATA :
+	  {
+	    const struct sctpDataPart *dataHdrPtr;
+
+	    printf("[DATA] ");
+
+	    if ((chunkDescPtr->chunkFlg & SCTP_DATA_UNORDERED)
+		== SCTP_DATA_UNORDERED)
+	      printf("(U)");
+
+	    if ((chunkDescPtr->chunkFlg & SCTP_DATA_FIRST_FRAG)
+		== SCTP_DATA_FIRST_FRAG)
+	      printf("(B)");
+
+	    if ((chunkDescPtr->chunkFlg & SCTP_DATA_LAST_FRAG)
+		== SCTP_DATA_LAST_FRAG)
+	      printf("(E)");
+
+	    if( ((chunkDescPtr->chunkFlg & SCTP_DATA_UNORDERED)
+		 == SCTP_DATA_UNORDERED)
+		||
+		((chunkDescPtr->chunkFlg & SCTP_DATA_FIRST_FRAG)
+		 == SCTP_DATA_FIRST_FRAG)
+		||
+		((chunkDescPtr->chunkFlg & SCTP_DATA_LAST_FRAG)
+		 == SCTP_DATA_LAST_FRAG) )
+	      printf(" ");
+
+	    dataHdrPtr=(const struct sctpDataPart*)(chunkDescPtr+1);
+
+	    printf("[TSN: %u] ", EXTRACT_32BITS(&dataHdrPtr->TSN));
+	    printf("[SID: %u] ", EXTRACT_16BITS(&dataHdrPtr->streamId));
+	    printf("[SSEQ %u] ", EXTRACT_16BITS(&dataHdrPtr->sequence));
+	    printf("[PPID 0x%x] ", EXTRACT_32BITS(&dataHdrPtr->payloadtype));
+	    fflush(stdout);
+	    if (isforces) {
+		const u_char *payloadPtr;
+		u_int chunksize = sizeof(struct sctpDataPart)+
+			          sizeof(struct sctpChunkDesc);
+		payloadPtr = (const u_char *) (dataHdrPtr + 1);
+		if (EXTRACT_16BITS(&chunkDescPtr->chunkLength) <
+			sizeof(struct sctpDataPart)+
+			sizeof(struct sctpChunkDesc)+1) {
+		/* Less than 1 byte of chunk payload */
+			printf("bogus ForCES chunk length %u]",
+			    EXTRACT_16BITS(&chunkDescPtr->chunkLength));
+			return;
+		}
+
+		forces_print(payloadPtr, EXTRACT_16BITS(&chunkDescPtr->chunkLength)- chunksize);
+	   } else if (vflag >= 2) {	/* if verbose output is specified */
+					/* at the command line */
+		const u_char *payloadPtr;
+
+		printf("[Payload");
+
+		if (!suppress_default_print) {
+			payloadPtr = (const u_char *) (++dataHdrPtr);
+			printf(":");
+			if (EXTRACT_16BITS(&chunkDescPtr->chunkLength) <
+			    sizeof(struct sctpDataPart)+
+			    sizeof(struct sctpChunkDesc)+1) {
+				/* Less than 1 byte of chunk payload */
+				printf("bogus chunk length %u]",
+				    EXTRACT_16BITS(&chunkDescPtr->chunkLength));
+				return;
+			}
+			default_print(payloadPtr,
+			      EXTRACT_16BITS(&chunkDescPtr->chunkLength) -
+			      (sizeof(struct sctpDataPart)+
+			      sizeof(struct sctpChunkDesc)));
+		} else
+			printf("]");
+	      }
+	    break;
+	  }
+	case SCTP_INITIATION :
+	  {
+	    const struct sctpInitiation *init;
+
+	    printf("[INIT] ");
+	    init=(const struct sctpInitiation*)(chunkDescPtr+1);
+	    printf("[init tag: %u] ", EXTRACT_32BITS(&init->initTag));
+	    printf("[rwnd: %u] ", EXTRACT_32BITS(&init->rcvWindowCredit));
+	    printf("[OS: %u] ", EXTRACT_16BITS(&init->NumPreopenStreams));
+	    printf("[MIS: %u] ", EXTRACT_16BITS(&init->MaxInboundStreams));
+	    printf("[init TSN: %u] ", EXTRACT_32BITS(&init->initialTSN));
+
+#if(0) /* ALC you can add code for optional params here */
+	    if( (init+1) < chunkEnd )
+	      printf(" @@@@@ UNFINISHED @@@@@@%s\n",
+		     "Optional params present, but not printed.");
+#endif
+	    break;
+	  }
+	case SCTP_INITIATION_ACK :
+	  {
+	    const struct sctpInitiation *init;
+
+	    printf("[INIT ACK] ");
+	    init=(const struct sctpInitiation*)(chunkDescPtr+1);
+	    printf("[init tag: %u] ", EXTRACT_32BITS(&init->initTag));
+	    printf("[rwnd: %u] ", EXTRACT_32BITS(&init->rcvWindowCredit));
+	    printf("[OS: %u] ", EXTRACT_16BITS(&init->NumPreopenStreams));
+	    printf("[MIS: %u] ", EXTRACT_16BITS(&init->MaxInboundStreams));
+	    printf("[init TSN: %u] ", EXTRACT_32BITS(&init->initialTSN));
+
+#if(0) /* ALC you can add code for optional params here */
+	    if( (init+1) < chunkEnd )
+	      printf(" @@@@@ UNFINISHED @@@@@@%s\n",
+		     "Optional params present, but not printed.");
+#endif
+	    break;
+	  }
+	case SCTP_SELECTIVE_ACK:
+	  {
+	    const struct sctpSelectiveAck *sack;
+	    const struct sctpSelectiveFrag *frag;
+	    int fragNo, tsnNo;
+	    const u_char *dupTSN;
+
+	    printf("[SACK] ");
+	    sack=(const struct sctpSelectiveAck*)(chunkDescPtr+1);
+	    printf("[cum ack %u] ", EXTRACT_32BITS(&sack->highestConseqTSN));
+	    printf("[a_rwnd %u] ", EXTRACT_32BITS(&sack->updatedRwnd));
+	    printf("[#gap acks %u] ", EXTRACT_16BITS(&sack->numberOfdesc));
+	    printf("[#dup tsns %u] ", EXTRACT_16BITS(&sack->numDupTsns));
+
+
+	    /* print gaps */
+	    for (frag = ( (const struct sctpSelectiveFrag *)
+			  ((const struct sctpSelectiveAck *) sack+1)),
+		   fragNo=0;
+		 (const void *)frag < nextChunk && fragNo < EXTRACT_16BITS(&sack->numberOfdesc);
+		 frag++, fragNo++)
+	      printf("\n\t\t[gap ack block #%d: start = %u, end = %u] ",
+		     fragNo+1,
+		     EXTRACT_32BITS(&sack->highestConseqTSN) + EXTRACT_16BITS(&frag->fragmentStart),
+		     EXTRACT_32BITS(&sack->highestConseqTSN) + EXTRACT_16BITS(&frag->fragmentEnd));
+
+
+	    /* print duplicate TSNs */
+	    for (dupTSN = (const u_char *)frag, tsnNo=0;
+		 (const void *) dupTSN < nextChunk && tsnNo<EXTRACT_16BITS(&sack->numDupTsns);
+		 dupTSN += 4, tsnNo++)
+	      printf("\n\t\t[dup TSN #%u: %u] ", tsnNo+1,
+	          EXTRACT_32BITS(dupTSN));
+
+	    break;
+	  }
+	case SCTP_HEARTBEAT_REQUEST :
+	  {
+	    const struct sctpHBsender *hb;
+
+	    hb=(const struct sctpHBsender*)chunkDescPtr;
+
+	    printf("[HB REQ] ");
+
+	    break;
+	  }
+	case SCTP_HEARTBEAT_ACK :
+	  printf("[HB ACK] ");
+	  break;
+	case SCTP_ABORT_ASSOCIATION :
+	  printf("[ABORT] ");
+	  break;
+	case SCTP_SHUTDOWN :
+	  printf("[SHUTDOWN] ");
+	  break;
+	case SCTP_SHUTDOWN_ACK :
+	  printf("[SHUTDOWN ACK] ");
+	  break;
+	case SCTP_OPERATION_ERR :
+	  printf("[OP ERR] ");
+	  break;
+	case SCTP_COOKIE_ECHO :
+	  printf("[COOKIE ECHO] ");
+	  break;
+	case SCTP_COOKIE_ACK :
+	  printf("[COOKIE ACK] ");
+	  break;
+	case SCTP_ECN_ECHO :
+	  printf("[ECN ECHO] ");
+	  break;
+	case SCTP_ECN_CWR :
+	  printf("[ECN CWR] ");
+	  break;
+	case SCTP_SHUTDOWN_COMPLETE :
+	  printf("[SHUTDOWN COMPLETE] ");
+	  break;
+	case SCTP_FORWARD_CUM_TSN :
+	  printf("[FOR CUM TSN] ");
+	  break;
+	case SCTP_RELIABLE_CNTL :
+	  printf("[REL CTRL] ");
+	  break;
+	case SCTP_RELIABLE_CNTL_ACK :
+	  printf("[REL CTRL ACK] ");
+	  break;
+	default :
+	  printf("[Unknown chunk type: 0x%x]", chunkDescPtr->chunkID);
+	  return;
+	}
+
+	if (vflag < 2)
+	  sep = ", (";
+    }
+    return;
+
+trunc:
+    printf("[|sctp]");
+    return;
+}