_ip6.c

This directory contains source code for tcpdump, a tool for network monitoring and data acquisition

/*
 * Copyright (c) 1988, 1989, 1990, 1991, 1992, 1993, 1994
 *      The Regents of the University of California.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that: (1) source code distributions
 * retain the above copyright notice and this paragraph in its entirety, (2)
 * distributions including binary code include the above copyright notice and
 * this paragraph in its entirety in the documentation or other materials
 * provided with the distribution, and (3) all advertising materials mentioning
 * features or use of this software display the following acknowledgement:
 * ``This product includes software developed by the University of California,
 * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
 * the University nor the names of its contributors may be used to endorse
 * or promote products derived from this software without specific prior
 * written permission.
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */

#if 0
static const char rcsid[] =
"@(#) $Header: /tcpdump/master/tcpdump/print-ip6.c,v 1.2.2.1 2000/01/11 06:58:25 fenner Exp $";
#endif

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#include <sys/param.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/socket.h>

#include "interfac.h"
#include "a2name.h"
#include "ip6.h"

#ifdef USE_INET6

/*
 * print an IP6 datagram.
 */
void ip6_print (const u_char * bp, u_int length)
{
  const struct ip6_hdr *ip6 = (const struct ip6_hdr*) bp;
  const u_char         *cp;
  int   advance, len, nh;
  int   fragmented = 0;
  DWORD flow;

#ifdef TCPDUMP_ALIGN
  /*
   * The IP header is not word aligned, so copy into abuf.
   * This will never happen with BPF.  It does happen raw packet
   * dumps from -r.
   */
  if ((int)ip & (sizeof(long) - 1))
  {
    static u_char *abuf;

    if (abuf == 0)
        abuf = malloc (snaplen);
    memcpy (abuf, ip, min (length, snaplen));
    snapend += abuf - (u_char *) ip;
    packetp  = abuf;
    ip = (struct ip6_hdr *) abuf;
  }
#endif

  if ((u_char*) (ip6 + 1) > snapend)
  {
    PUTS ("[|ip6]");
    return;
  }
  if (length < sizeof(struct ip6_hdr))
  {
    PRINTF ("truncated-ip6 %u", length);
    return;
  }
  advance = sizeof(struct ip6_hdr);
  len = ntohs (ip6->ip6_plen);

  if (length < len + advance)
     PRINTF ("truncated-ip6 - %d bytes missing!", len + advance - length);

  cp = (const u_char *) ip6;
  nh = ip6->ip6_nxt;
  while (cp < snapend)
  {
    cp += advance;

    if (cp == (u_char *) (ip6 + 1) && nh != IPPROTO_TCP && nh != IPPROTO_UDP)
       PRINTF ("%s > %s: ",
               ip6addr_string (&ip6->ip6_src),
               ip6addr_string (&ip6->ip6_dst));

    switch (nh)
    {
      case IPPROTO_HOPOPTS:
           advance = hbhopt_print (cp);
           nh = *cp;
           break;

      case IPPROTO_DSTOPTS:
           advance = dstopt_print (cp);
           nh = *cp;
           break;

      case IPPROTO_FRAGMENT:
           advance = frag6_print (cp, (const u_char*)ip6);
           if (snapend <= cp + advance)
              goto end;
           nh = *cp;
           fragmented = 1;
           break;

      case IPPROTO_ROUTING:
           advance = rt6_print (cp, (const u_char*)ip6);
           nh = *cp;
           break;

      case IPPROTO_TCP:
           tcp_print (cp, len + sizeof(*ip6) - (cp - bp), (const u_char*)ip6, fragmented);
           goto end;

      case IPPROTO_UDP:
           udp_print (cp, len + sizeof(*ip6) - (cp - bp), (const u_char*)ip6, fragmented);
           goto end;

      case IPPROTO_ICMPV6:
           icmp6_print (cp, len + sizeof(*ip6) - (cp - bp));
           goto end;

      case IPPROTO_AH:
           advance = ah_print (cp);
           nh = *cp;
           break;

      case IPPROTO_ESP:
           {
             int enh;

             advance += esp_print (cp, (const u_char*)ip6, &enh);
             if (enh < 0)
                goto end;
             nh = enh & 0xff;
             break;
           }

      case IPPROTO_IPCOMP:
           {
             int enh;

             advance += ipcomp_print (cp, (const u_char*)ip6, &enh);
             if (enh < 0)
                goto end;
             nh = enh & 0xff;
             break;
           }

      case IPPROTO_PIM:
           PUTS ("PIM");
           pim_print (cp, len);
           goto end;

      case IPPROTO_RSVP:
           PUTS (" rsvp");
#ifdef USE_RSVP
           ntoh_rsvp_packet (cp, len);
           rsvp_print_pkt (cp, len);
#endif
           goto end;

      case IPPROTO_OSPF:
           ospf6_print (cp, len);
           goto end;

      case IPPROTO_IPV6:
           ip6_print (cp, len);
           goto end;

      case IPPROTO_IPV4:
           ip_print (cp, len);
           goto end;

      case IPPROTO_NONE:
           PUTS ("no next header");
           goto end;

      default:
           PRINTF ("ip-proto-%d %d", ip6->ip6_nxt, len);
           goto end;
    }
  }

end:
  flow = ntohl (ip6->ip6_flow);

#if 0
  /* rfc1883 */
  if (flow & 0x0f000000)
     PRINTF (" [pri 0x%x]", (flow & 0x0f000000) >> 24);

  if (flow & 0x00ffffff)
     PRINTF (" [flowlabel 0x%x]", flow & 0x00ffffff);

#else /* RFC 2460 */
  if (flow & 0x0ff00000)
     PRINTF (" [class 0x%x]", (flow & 0x0ff00000) >> 20);
  if (flow & 0x000fffff)
     PRINTF (" [flowlabel 0x%x]", flow & 0x000fffff);
#endif

  if (ip6->ip6_hlim <= 1)
     PRINTF (" [hlim %d]", (int) ip6->ip6_hlim);

  if (vflag)
  {
    PRINTF (" (len %d", len);
    if (ip6->ip6_hlim > 1)
       PRINTF (", hlim %d", ip6->ip6_hlim);
    PUTCHAR (')');
  }
}
#endif  /* USE_INET6 */