_icmp6.c

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

    default:
         PRINTF (" opt%d/%d", opt->type, opt->length);
         return;
  }

  if (!opt->length)
  {
    PUTCHAR (']');
    return;
  }
  if (opt->length * 8 > len)
  {
    PRINTF ("%s]", ((u_char*)opt) + opt->length * 8 > snapend ?
            "|" : "t!runcated");
    return;
  }

  for (i = 0; i < (opt->length * 8) - 2; i++)
  {
    char buf[16];

    sprintf (buf, "%02x", ((u_char*)(opt + 1))[i]);
    if (i == (opt->length * 8) - 3)
         PRINTF ("%s]", (char*)buf);
    else PRINTF ("%s:", (char*)buf);
  }
}

void ndisc_print_options (u_char *bp, int length)
{
  struct ndisc_opt *opt = (struct ndisc_opt*)bp;
  int    offset = 0;

  while (offset + 2 <= length)
  {
    ndisc_opt_print (opt, length - offset);
    if (opt->length == 0)
    {
      PUTS ("[optlen==0!]");
      break;
    }
    offset += opt->length * 8;
    opt = (struct ndisc_opt*) (bp + offset);
  }
}

void icmp6_print (const u_char *bp, u_int length)
{
  const struct icmp6_hdr *dp;
  char  buf[256], *str;
  int   left, rep_off = -1;

  dp   = (struct icmp6_hdr*)bp;
  left = (u_long) snapend - (u_long) bp;
  str  = buf;
  *str = '\0';

  if (left < ICMPV6_MINLEN)
     goto trunc;

  switch (dp->icmp6_type)
  {
    case ICMPV6_ECHOREPLY:
         str = "echo reply";
         break;

    case ICMPV6_UNREACH:
         switch (dp->icmp6_code)
         {
           case ICMPV6_UNREACH_NOROUTE:
                str = "no route";
                break;
           case ICMPV6_UNREACH_ADMIN:
                str = "admin prohibited";
                break;
           case ICMPV6_UNREACH_NOTNEIGHBOR:
                str = "not a neighbor";
                break;
           case ICMPV6_UNREACH_ADDRESS:
                str = "host unreachable";
                break;
           case ICMPV6_UNREACH_PORT:
                str = "port unreachable";
                break;
         }
         rep_off = 8;
         break;

    case ICMPV6_TOOBIG:
         sprintf (str, "packet too big: mtu[%lu]", ntohl (dp->icmp6_mtu));
         rep_off = 8;
         break;

    case ICMPV6_ECHO:
         str = "echo request";
         break;

    case ICMPV6_GRPQUERY:
#if 0 /* !! */
         if (!memcmp (dp+1, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", 16))
              sprintf (str, "MLD general query: resptime=%dmsec",
                       ntohs (dp->icmp_grpdelay));
         else sprintf (str, "MLD query: %s resptime=%dmsec",
                       ip6addr_string ((struct in6_addr*) (dp + 1)),
                       ntohs (dp->icmp_grpdelay));
#else
         strcpy (str, "MLD query");
#endif
         break;

    case ICMPV6_GRPREPORT:
         sprintf (str, "MLD report: %s",
                  ip6addr_string ((struct in6_addr*)(dp + 1)));
         break;

    case ICMPV6_GRPTERM:
         sprintf (str, "MLD reduction: %s",
                  ip6addr_string ((struct in6_addr*)(dp + 1)));
         break;

    case ICMPV6_TIMXCEED:
         switch (dp->icmp6_code)
         {
           case ICMPV6_TIMXCEED_INTRANS:
                str = "time exceeded in-transit";
                break;
           case ICMPV6_TIMXCEED_REASS:
                str = "reassembly time exceeded";
                break;
         }
         rep_off = 8;
         break;

    case ICMPV6_PARAMPROB:
         switch (dp->icmp6_code)
         {
           case ICMPV6_PARAMPROB_PROB:
                strcpy (str, "incorrect parameter");
                break;
           case ICMPV6_PARAMPROB_NEXTHDR:
                strcpy (str, "bad next header");
                break;
           case ICMPV6_PARAMPROB_BADOPT:
                strcpy (str, "unrec. option");
                break;
         }
         sprintf (str + strlen(str), " ptr[%lu]", ntohl(dp->icmp6_pptr));
         rep_off = 8;
         break;

    case ICMPV6_ROUTERSOL:
         {
           struct rs_hdr *rs;

           PUTS ("icmpv6: RS");
           if (left < sizeof(*rs))
           {
             PUTS ("[|]");
             return;
           }
           rs = (struct rs_hdr *) bp;
           if (rs->reserved)
              PRINTF (" ?%08x", ntohl (rs->reserved));
           if (vflag)
              ndisc_print_options ((u_char*)(rs+1), left - sizeof(*rs));
           return;
         }

    case ICMPV6_ROUTERADV:
         {
           struct ra_hdr *ra;

           PUTS ("icmpv6: RA");
           if (left < sizeof(*ra))
           {
             PUTS ("[|]");
             return;
           }
           ra = (struct ra_hdr*)bp;
           if (ra->flags)
           {
             PUTCHAR ('(');
             if (ra->flags & RA_MANAGED)
                PUTCHAR ('M');
             if (ra->flags & RA_OTHER_STATEFUL)
                PUTCHAR ('O');
             if (ra->flags & RA_RESERVED)
                PRINTF ("?%02x", ra->flags & RA_RESERVED);
             PUTCHAR (')');
           }
           if (vflag)
           {
             if (ra->router_lft)
                PRINTF (" default %ds", ntohs (ra->router_lft));
             if (ra->hoplimit)
                PRINTF (" hoplimit %d", ra->hoplimit);
             if (ra->reachable)
                PRINTF (" reachable %dms", ntohl (ra->reachable));
             if (ra->retrans)
                PRINTF (" retrans %dms", ntohl (ra->retrans));
             ndisc_print_options ((u_char*)(ra+1), left - sizeof(*ra));
           }
           return;
         }

    case ICMPV6_NEIGHBORSOL:
         {
           struct ns_hdr *ns;

           PUTS ("icmpv6: NS");
           if (left < sizeof(*ns))
           {
             PUTS ("[|]");
             return;
           }
           ns = (struct ns_hdr*)bp;
           PRINTF (" %s", ip6addr_string (&ns->target));
           if (ns->reserved)
              PRINTF (" ?%08x", ntohl (ns->reserved));
           if (vflag)
              ndisc_print_options ((u_char*)(ns+1), left - sizeof(*ns));
           return;
         }

    case ICMPV6_NEIGHBORADV:
         {
           struct na_hdr *na;

           PUTS ("icmpv6: NA");
           if (left < sizeof(*na))
           {
             PUTS ("[|]");
             return;
           }
           na = (struct na_hdr*)bp;

                   PRINTF (" %s", ip6addr_string (&na->targ_addr));
           if (na->flags)
           {
             PUTCHAR ('(');
             if (na->flags & NA_ROUTER)
                PUTCHAR ('R');
             if (na->flags & NA_SOLICITED)
                PUTCHAR ('S');
             if (na->flags & NA_OVERRIDE)
                PUTCHAR ('O');
             if (na->flags & NA_RESERVED)
                PRINTF ("?%08x", ntohl (na->flags & NA_RESERVED));
             PUTCHAR (')');
           }
           if (vflag)
              ndisc_print_options ((u_char*)(na+1), left - sizeof(*na));
           return;
         }

    case ICMPV6_REDIRECT:
         {
           struct red_hdr *red;

           PUTS ("icmpv6: redirect ");
           if (left < sizeof(*red))
           {
             PUTS ("[|]");
             return;
           }
           red = (struct red_hdr*)bp;

           PRINTF (" %s", ip6addr_string (&red->destination));
           if (memcmp (&red->destination, &red->target, 16) == 0)
                PUTS (" direct");
           else PRINTF (" to %s", ip6addr_string (&red->target));
           if (vflag)
             ndisc_print_options ((u_char*)(red + 1), left - sizeof(*red));
           return;
         }

    default:
         sprintf (buf, "type#%d/%d", dp->icmp6_type, dp->icmp6_code);
         break;
  }

  PRINTF ("icmpv6: %s", str);
  if (vflag > 1 && rep_off > 0)
  {
    PUTS (" Offending pkt: ");
    partial_frame++;
    ip6_print (bp + rep_off, length - rep_off);
    partial_frame--;
  }
  return;

trunc:
  PUTS ("[|icmpv6]");
}

#endif