Get rid of unneeded includes of <netinet/in_systm.h> and <netinet/ip.h>.

[tcpdump] / print-sctp.c

diff --git a/print-sctp.c b/print-sctp.c
index 1b93714467bd3f07543eee5465b3909c427157e4..43a71c5d34d6f34e93bf9ca02b79a4f4a2a70463 100644 (file)
--- a/print-sctp.c
+++ b/print-sctp.c
@@ -35,7 +35,7 @@
 
 #ifndef lint
 static const char rcsid[] =
 
 #ifndef lint
 static const char rcsid[] =

-"@(#) $Header: /tcpdump/master/tcpdump/print-sctp.c,v 1.1 2001-05-09 00:34:35 fenner Exp $ (NETLAB/PEL)";
+"@(#) $Header: /tcpdump/master/tcpdump/print-sctp.c,v 1.8 2002-04-25 04:45:59 guy Exp $ (NETLAB/PEL)";

 #endif
 
 #ifdef HAVE_CONFIG_H
 #endif
 
 #ifdef HAVE_CONFIG_H


@@ -51,12 +51,6 @@ static const char rcsid[] =
 #include "sctpConstants.h"
 #include <assert.h>
 
 #include "sctpConstants.h"
 #include <assert.h>
 

-#if __STDC__
-struct mbuf;
-struct rtentry;
-#endif
-#include <net/if.h>
-

 #include <netinet/in.h>
 
 #include <stdio.h>
 #include <netinet/in.h>
 
 #include <stdio.h>


@@ -80,25 +74,25 @@ void sctp_print(const u_char *bp,        /* beginning of sctp packet */
   const struct ip6_hdr *ip6;
 #endif
   const u_char *cp;
   const struct ip6_hdr *ip6;
 #endif
   const u_char *cp;

-  void *endPacketPtr;
+  const void *endPacketPtr;

   u_short sourcePort, destPort;
   int chunkCount;
   u_short sourcePort, destPort;
   int chunkCount;

-  struct sctpChunkDesc *chunkDescPtr;
-  void *nextChunk;
+  const struct sctpChunkDesc *chunkDescPtr;
+  const void *nextChunk;

 
 

-  sctpPktHdr = (struct sctpHeader*) bp;
-  endPacketPtr = ((u_char*)((u_char*)sctpPktHdr+sctpPacketLength));
+  sctpPktHdr = (const struct sctpHeader*) bp;
+  endPacketPtr = (const u_char*)sctpPktHdr+sctpPacketLength;

   
   if( (u_long) endPacketPtr > (u_long) snapend)
   
   if( (u_long) endPacketPtr > (u_long) snapend)

-    endPacketPtr = (void *) snapend;
+    endPacketPtr = (const void *) snapend;

   ip = (struct ip *)bp2;
 #ifdef INET6
   if (IP_V(ip) == 6)
   ip = (struct ip *)bp2;
 #ifdef INET6
   if (IP_V(ip) == 6)

-    ip6 = (struct ip6_hdr *)bp2;
+    ip6 = (const struct ip6_hdr *)bp2;

   else
     ip6 = NULL;
 #endif /*INET6*/
   else
     ip6 = NULL;
 #endif /*INET6*/

-  cp = (u_char *)(sctpPktHdr + 1);
+  cp = (const u_char *)(sctpPktHdr + 1);

   if (cp > snapend)
     { 
       printf("[|sctp]");
   if (cp > snapend)
     { 
       printf("[|sctp]");


@@ -107,8 +101,8 @@ void sctp_print(const u_char *bp,        /* beginning of sctp packet */
 
   if (sctpPacketLength < sizeof(struct sctpHeader)) 
     {
 
   if (sctpPacketLength < sizeof(struct sctpHeader)) 
     {

-      (void)printf("truncated-sctp - %d bytes missing!", 
-                  sctpPacketLength-sizeof(struct sctpHeader));
+      (void)printf("truncated-sctp - %ld bytes missing!", 
+                  (long)sctpPacketLength-sizeof(struct sctpHeader));

       return;
     }
   
       return;
     }
   


@@ -151,31 +145,32 @@ void sctp_print(const u_char *bp,        /* beginning of sctp packet */
   
   /* cycle through all chunks, printing information on each one */
   for (chunkCount = 0, 
   
   /* cycle through all chunks, printing information on each one */
   for (chunkCount = 0, 

-        chunkDescPtr = (struct sctpChunkDesc *) ( (u_char*) sctpPktHdr +
-                                                  sizeof(struct sctpHeader));
+        chunkDescPtr = (const struct sctpChunkDesc *)
+           ((const u_char*) sctpPktHdr + sizeof(struct sctpHeader));

        chunkDescPtr != NULL &&
        chunkDescPtr != NULL &&

-        ( (void *)  ((u_char *) chunkDescPtr + sizeof(struct sctpChunkDesc))
+        ( (const void *)
+           ((const u_char *) chunkDescPtr + sizeof(struct sctpChunkDesc))

           <= endPacketPtr);
        
           <= endPacketPtr);
        

-       chunkDescPtr = (struct sctpChunkDesc *) nextChunk, chunkCount++)
+       chunkDescPtr = (const struct sctpChunkDesc *) nextChunk, chunkCount++)

     {
       u_short align;
     {
       u_short align;

-      u_char *chunkEnd;
+      const u_char *chunkEnd;

       
       

-      chunkEnd = ((u_char*)chunkDescPtr + ntohs(chunkDescPtr->chunkLength));
+      chunkEnd = ((const u_char*)chunkDescPtr + ntohs(chunkDescPtr->chunkLength));

       
       align=ntohs(chunkDescPtr->chunkLength) % 4;
       if (align != 0)
        align = 4 - align;
 
       
       align=ntohs(chunkDescPtr->chunkLength) % 4;
       if (align != 0)
        align = 4 - align;
 

-      nextChunk = (void *) (chunkEnd + align);
+      nextChunk = (const void *) (chunkEnd + align);

 
       printf("\n\t%d) ", chunkCount+1);
       switch (chunkDescPtr->chunkID)
        {
        case SCTP_DATA :
          {
 
       printf("\n\t%d) ", chunkCount+1);
       switch (chunkDescPtr->chunkID)
        {
        case SCTP_DATA :
          {

-           struct sctpDataPart *dataHdrPtr;
+           const struct sctpDataPart *dataHdrPtr;

            
            printf("[DATA] ");
            
            
            printf("[DATA] ");
            


@@ -201,41 +196,42 @@ void sctp_print(const u_char *bp,        /* beginning of sctp packet */
                 == SCTP_DATA_LAST_FRAG) )
              printf(" ");
 
                 == SCTP_DATA_LAST_FRAG) )
              printf(" ");
 

-           dataHdrPtr=(struct sctpDataPart*)(chunkDescPtr+1);
+           dataHdrPtr=(const struct sctpDataPart*)(chunkDescPtr+1);

                             
                             

-           printf("[TSN: %lu] ", ntohl(dataHdrPtr->TSN));
+           printf("[TSN: %u] ", (u_int32_t)ntohl(dataHdrPtr->TSN));

            printf("[SID: %u] ", ntohs(dataHdrPtr->streamId));
            printf("[SSEQ %u] ", ntohs(dataHdrPtr->sequence));
            printf("[SID: %u] ", ntohs(dataHdrPtr->streamId));
            printf("[SSEQ %u] ", ntohs(dataHdrPtr->sequence));

-           printf("[PPID 0x%x] ", ntohl(dataHdrPtr->payloadtype));
+           printf("[PPID 0x%x] ", (u_int32_t)ntohl(dataHdrPtr->payloadtype));

            fflush(stdout);
 
            if (vflag)          /* if verbose output is specified */
              {                    /* at the command line */
            fflush(stdout);
 
            if (vflag)          /* if verbose output is specified */
              {                    /* at the command line */

-               char *payloadPtr;
+               const u_char *payloadPtr;

                
                

-               printf("[Payload: {");
-               fflush(stdout);
+               printf("[Payload");

 
 

-               payloadPtr = (char *) (++dataHdrPtr);
-               write(STDOUT_FILENO, payloadPtr, 
-                     htons(chunkDescPtr->chunkLength)-1 -
-                     sizeof(struct sctpDataPart)-sizeof(struct sctpChunkDesc));
-               printf("}] ");
-               fflush(stdout);
+               if (!xflag && !qflag) {
+                       payloadPtr = (const u_char *) (++dataHdrPtr);
+                       printf(":");
+                       default_print(payloadPtr,
+                             htons(chunkDescPtr->chunkLength)-1 -
+                             sizeof(struct sctpDataPart)-sizeof(struct sctpChunkDesc));
+               } else
+                       printf("]");

              }
            break;
          }
        case SCTP_INITIATION :
          {
              }
            break;
          }
        case SCTP_INITIATION :
          {

-           struct sctpInitiation *init;
+           const struct sctpInitiation *init;

 
            printf("[INIT] ");
 
            printf("[INIT] ");

-           init=(struct sctpInitiation*)(chunkDescPtr+1);
-           printf("[init tag: %lu] ", ntohl(init->initTag));
-           printf("[rwnd: %lu] ", ntohl(init->rcvWindowCredit));
+           init=(const struct sctpInitiation*)(chunkDescPtr+1);
+           printf("[init tag: %u] ", (u_int32_t)ntohl(init->initTag));
+           printf("[rwnd: %u] ", (u_int32_t)ntohl(init->rcvWindowCredit));

            printf("[OS: %u] ", ntohs(init->NumPreopenStreams));
            printf("[MIS: %u] ", ntohs(init->MaxInboundStreams));
            printf("[OS: %u] ", ntohs(init->NumPreopenStreams));
            printf("[MIS: %u] ", ntohs(init->MaxInboundStreams));

-           printf("[init TSN: %lu] ", ntohl(init->initialTSN));
+           printf("[init TSN: %u] ", (u_int32_t)ntohl(init->initialTSN));

 
 #if(0) /* ALC you can add code for optional params here */
            if( (init+1) < chunkEnd )
 
 #if(0) /* ALC you can add code for optional params here */
            if( (init+1) < chunkEnd )


@@ -246,15 +242,15 @@ void sctp_print(const u_char *bp,        /* beginning of sctp packet */
          }
        case SCTP_INITIATION_ACK :
          {
          }
        case SCTP_INITIATION_ACK :
          {

-           struct sctpInitiation *init;
+           const struct sctpInitiation *init;

            
            printf("[INIT ACK] ");
            
            printf("[INIT ACK] ");

-           init=(struct sctpInitiation*)(chunkDescPtr+1);
-           printf("[init tag: %lu] ", ntohl(init->initTag));
-           printf("[rwnd: %lu] ", ntohl(init->rcvWindowCredit));
+           init=(const struct sctpInitiation*)(chunkDescPtr+1);
+           printf("[init tag: %u] ", (u_int32_t)ntohl(init->initTag));
+           printf("[rwnd: %u] ", (u_int32_t)ntohl(init->rcvWindowCredit));

            printf("[OS: %u] ", ntohs(init->NumPreopenStreams));
            printf("[MIS: %u] ", ntohs(init->MaxInboundStreams));
            printf("[OS: %u] ", ntohs(init->NumPreopenStreams));
            printf("[MIS: %u] ", ntohs(init->MaxInboundStreams));

-           printf("[init TSN: %lu] ", ntohl(init->initialTSN));
+           printf("[init TSN: %u] ", (u_int32_t)ntohl(init->initialTSN));

            
 #if(0) /* ALC you can add code for optional params here */
            if( (init+1) < chunkEnd )
            
 #if(0) /* ALC you can add code for optional params here */
            if( (init+1) < chunkEnd )


@@ -265,44 +261,45 @@ void sctp_print(const u_char *bp,        /* beginning of sctp packet */
          }
        case SCTP_SELECTIVE_ACK:
          {
          }
        case SCTP_SELECTIVE_ACK:
          {

-           struct sctpSelectiveAck *sack;
-           struct sctpSelectiveFrag *frag; 
+           const struct sctpSelectiveAck *sack;
+           const struct sctpSelectiveFrag *frag; 

            int fragNo, tsnNo;
            int fragNo, tsnNo;

-           u_long *dupTSN;
+           const u_long *dupTSN;

 
            printf("[SACK] ");
 
            printf("[SACK] ");

-           sack=(struct sctpSelectiveAck*)(chunkDescPtr+1);
-           printf("[cum ack %lu] ", ntohl(sack->highestConseqTSN));
-           printf("[a_rwnd %lu] ", ntohl(sack->updatedRwnd));
+           sack=(const struct sctpSelectiveAck*)(chunkDescPtr+1);
+           printf("[cum ack %u] ", (u_int32_t)ntohl(sack->highestConseqTSN));
+           printf("[a_rwnd %u] ", (u_int32_t)ntohl(sack->updatedRwnd));

            printf("[#gap acks %u] ", ntohs(sack->numberOfdesc));
            printf("[#dup tsns %u] ", ntohs(sack->numDupTsns));
            
            
            /* print gaps */
            printf("[#gap acks %u] ", ntohs(sack->numberOfdesc));
            printf("[#dup tsns %u] ", ntohs(sack->numDupTsns));
            
            
            /* print gaps */

-           for (frag = ( (struct sctpSelectiveFrag *)
-                         ((struct sctpSelectiveAck *) sack+1)),
+           for (frag = ( (const struct sctpSelectiveFrag *)
+                         ((const struct sctpSelectiveAck *) sack+1)),

                   fragNo=0;
                   fragNo=0;

-                (void *)frag < nextChunk && fragNo < ntohs(sack->numberOfdesc);
+                (const void *)frag < nextChunk && fragNo < ntohs(sack->numberOfdesc);

                 frag++, fragNo++)
              printf("\n\t\t[gap ack block #%d: start = %u, end = %u] ", 
                     fragNo+1,
                 frag++, fragNo++)
              printf("\n\t\t[gap ack block #%d: start = %u, end = %u] ", 
                     fragNo+1,

-                    ntohl(sack->highestConseqTSN) + ntohs(frag->fragmentStart),
-                    ntohl(sack->highestConseqTSN) + ntohs(frag->fragmentEnd));
+                    (u_int32_t)(ntohl(sack->highestConseqTSN) + ntohs(frag->fragmentStart)),
+                    (u_int32_t)(ntohl(sack->highestConseqTSN) + ntohs(frag->fragmentEnd)));

            
 
            /* print duplicate TSNs */
            
 
            /* print duplicate TSNs */

-           for (dupTSN = (u_long*)frag, tsnNo=0; 
-                (void *) dupTSN < nextChunk && tsnNo<ntohs(sack->numDupTsns);
+           for (dupTSN = (const u_long*)frag, tsnNo=0; 
+                (const void *) dupTSN < nextChunk && tsnNo<ntohs(sack->numDupTsns);

                 dupTSN++, tsnNo++)
                 dupTSN++, tsnNo++)

-             printf("\n\t\t[dup TSN #%u: %lu] ", tsnNo+1, ntohl(*dupTSN));
+             printf("\n\t\t[dup TSN #%u: %u] ", tsnNo+1,
+                 (u_int32_t)ntohl(*dupTSN));

 
            break;
          }
        case SCTP_HEARTBEAT_REQUEST :
          {
 
            break;
          }
        case SCTP_HEARTBEAT_REQUEST :
          {

-           struct sctpHBsender *hb;
+           const struct sctpHBsender *hb;

 
 

-           hb=(struct sctpHBsender*)chunkDescPtr;
+           hb=(const struct sctpHBsender*)chunkDescPtr;

 
            printf("[HB REQ] ");
            
 
            printf("[HB REQ] ");