_l2tp.c

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

{
  print_int ((u_int *) dat);
}

static void l2tp_minimum_bps_print (const u_char * dat, u_int length)
{
  print_int ((u_int *) dat);
}

static void l2tp_maximum_bps_print (const u_char * dat, u_int length)
{
  print_int ((u_int *) dat);
}

static void l2tp_bearer_type_print (const u_char * dat, u_int length)
{
  u_int *ptr = (u_int *) dat;

  if (ntohl (*ptr) & L2TP_BEARER_TYPE_ANALOG_MASK)
    PUTCHAR ('A');

  if (ntohl (*ptr) & L2TP_BEARER_TYPE_DIGITAL_MASK)
    PUTCHAR ('D');
}

static void l2tp_framing_type_print (const u_char * dat, u_int length)
{
  u_int *ptr = (u_int *) dat;

  if (ntohl (*ptr) & L2TP_FRAMING_TYPE_ASYNC_MASK)
    PUTCHAR ('A');

  if (ntohl (*ptr) & L2TP_FRAMING_TYPE_SYNC_MASK)
    PUTCHAR ('S');
}

static void l2tp_packet_proc_delay_print (const u_char * dat, u_int length)
{
  PUTS ("obsolete");
}

static void l2tp_called_number_print (const u_char * dat, u_int length)
{
  print_string (dat, length);
}

static void l2tp_calling_number_print (const u_char * dat, u_int length)
{
  print_string (dat, length);
}

static void l2tp_sub_address_print (const u_char * dat, u_int length)
{
  print_string (dat, length);
}

static void l2tp_tx_conn_speed_print (const u_char * dat, u_int length)
{
  print_int ((u_int *) dat);
}

static void l2tp_phy_channel_id_print (const u_char * dat, u_int length)
{
  print_int ((u_int *) dat);
}

static void l2tp_ini_recv_lcp_print (const u_char * dat, u_int length)
{
  print_octets (dat, length);
}

static void l2tp_last_sent_lcp_print (const u_char * dat, u_int length)
{
  print_octets (dat, length);
}

static void l2tp_last_recv_lcp_print (const u_char * dat, u_int length)
{
  print_octets (dat, length);
}

static void l2tp_proxy_auth_type_print (const u_char * dat, u_int length)
{
  u_short *ptr = (u_short *) dat;

  switch (ntohs (*ptr))
  {
    case L2TP_AUTHEN_TYPE_RESERVED:
         PUTS ("Reserved");
         break;
    case L2TP_AUTHEN_TYPE_TEXTUAL:
         PUTS ("Textual");
         break;
    case L2TP_AUTHEN_TYPE_CHAP:
         PUTS ("CHAP");
         break;
    case L2TP_AUTHEN_TYPE_PAP:
         PUTS ("PAP");
         break;
    case L2TP_AUTHEN_TYPE_NO_AUTH:
         PUTS ("No Auth");
         break;
    case L2TP_AUTHEN_TYPE_MSCHAP:
         PUTS ("MS-CHAP");
         break;
    default:
         PUTS ("unknown");
  }
}

static void l2tp_proxy_auth_name_print (const u_char * dat, u_int length)
{
  print_octets (dat, length);
}

static void l2tp_proxy_auth_chal_print (const u_char * dat, u_int length)
{
  print_octets (dat, length);
}

static void l2tp_proxy_auth_id_print (const u_char * dat, u_int length)
{
  u_short *ptr = (u_short *) dat;

  PRINTF ("%u", ntohs (*ptr) & L2TP_PROXY_AUTH_ID_MASK);
}

static void l2tp_proxy_auth_resp_print (const u_char * dat, u_int length)
{
  print_octets (dat, length);
}

static void l2tp_call_errors_print (const u_char * dat, u_int length)
{
  struct l2tp_call_errors *ptr = (struct l2tp_call_errors *) dat;

  PRINTF ("CRCErr=%d FrameErr=%d HardOver=%d BufOver=%d ",
          ptr->crc_errs, ptr->framing_errs, ptr->hardware_overruns,
          ptr->buffer_overruns);
  PRINTF ("Timeout=%d AlingErr=%d", ptr->timeout_errs, ptr->alignment_errs);
}

static void l2tp_accm_print (const u_char * dat, u_int length)
{
  struct l2tp_accm *ptr = (struct l2tp_accm *) dat;

  PRINTF ("send=%x recv=%x", ptr->send_accm, ptr->recv_accm);
}

static void l2tp_random_vector_print (const u_char * dat, u_int length)
{
  print_octets (dat, length);
}

static void l2tp_private_grp_id_print (const u_char * dat, u_int length)
{
  print_string (dat, length);
  /* XXX print_octets is more appropriate?? */
}

static void l2tp_rx_conn_speed_print (const u_char * dat, u_int length)
{
  print_int ((u_int *) dat);
}

static void l2tp_seq_required_print (const u_char * dat, u_int length)
{
       return;
}

static void l2tp_ppp_discon_cc_print (const u_char *dat, u_int length)
{
  print_short ((u_short*)dat);
  PUTS (", ");
  print_short ((u_short*)(dat+2));
  PRINTF (", %02x", dat[4]);
  if (length > 5)
  {
    PUTCHAR (' ');
    print_string (dat+5, length-4);
  }
}

static void l2tp_not_defined_print(const u_char *dat, u_int length)
{
  return;
}

static void l2tp_avp_print (const u_char * dat, u_int length)
{
  const u_short *ptr = (u_short *) dat;
  u_int len;
  int   hidden = FALSE;

  PUTCHAR (' ');
  if (length > 0 && (snapend - dat) >= 2)
  {
    /* there must be at least two octets for the length
     * to be decoded */
    if ((len = (ntohs (*ptr) & L2TP_AVP_HDR_LEN_MASK)) <= (snapend - dat))
    {
      if (ntohs (*ptr) & L2TP_AVP_HDR_FLAG_MANDATORY)
         PUTCHAR ('*');
      if (ntohs (*ptr) & L2TP_AVP_HDR_FLAG_HIDDEN)
      {
        hidden = TRUE;
        PUTCHAR ('?');
      }
    }
    else
    {
      PUTS ("|...");
      return;
    }
    ptr++;

    if (ntohs (*ptr))         /* IETF == 0 */
      PRINTF ("vendor=%04x", ntohs (*ptr));

    ptr++;

    if (ntohs (*ptr) < L2TP_MAX_AVP_INDEX)
    {
      PUTS (l2tp_avp[ntohs (*ptr)].name);
      PUTCHAR ('(');
      if (!hidden)
           (l2tp_avp[ntohs (*ptr)].print) ((u_char *) ptr + 2, len - 6);
      else PUTS ("???");
      PUTCHAR (')');
    }
    else
      PRINTF (" invalid AVP %u", ntohs (*ptr));

    l2tp_avp_print (dat + len, length - len);
  }
  else if (length == 0)
    return;

  PUTS ("|...");
}


void l2tp_print (const u_char * dat, u_int length)
{
  const   u_short *ptr = (u_short *) dat;
  int     flag_t, flag_l, flag_s, flag_o, flag_p;
  u_short l2tp_len, pad;
  u_int   cnt = 0;                /* total octets consumed */

  flag_t = flag_l = flag_s = flag_o = flag_p = FALSE;

  if (min ((long)length, (long)(snapend - dat)) - 6 < 0)
  {
    /* flag/ver, tunnel_id, session_id must be present for
     * this packet to be properly decoded
     */
    PUTS (tstr);
    return;
  }

  if ((ntohs (*ptr) & L2TP_VERSION_MASK) == L2TP_VERSION_L2TP)
    PUTS (" l2tp:");

  else if ((ntohs (*ptr) & L2TP_VERSION_MASK) == L2TP_VERSION_L2F)
  {
    PUTS (" l2f:");
    return;                     /* nothing to do */
  }
  else
  {
    PUTS (" Unknown Version, neither L2F(1) nor L2TP(2)");
    return;                     /* nothing we can do */
  }

  PUTCHAR ('[');
  if (ntohs (*ptr) & L2TP_FLAG_TYPE)
  {
    flag_t = TRUE;
    PUTCHAR ('T');
  }
  if (ntohs (*ptr) & L2TP_FLAG_LENGTH)
  {
    flag_l = TRUE;
    PUTCHAR ('L');
  }
  if (ntohs (*ptr) & L2TP_FLAG_SEQUENCE)
  {
    flag_s = TRUE;
    PUTCHAR ('S');
  }
  if (ntohs (*ptr) & L2TP_FLAG_OFFSET)
  {
    flag_o = TRUE;
    PUTCHAR ('O');
  }
  if (ntohs (*ptr) & L2TP_FLAG_PRIORITY)
  {
    flag_p = TRUE;
    PUTCHAR ('P');
  }
  PUTCHAR (']');

  ptr++;
  cnt += 2;

  if (flag_l)
  {
    l2tp_len = ntohs (*ptr++);  /* XXX need to consider truncation ?? */
    cnt += 2;
  }
  else
    l2tp_len = 0;

  PRINTF ("(%u/", ntohs (*ptr++));  /* Tunnel ID */
  PRINTF ("%u)", ntohs (*ptr++));   /* Session ID */
  cnt += 4;

  if (flag_s)
  {
    PRINTF ("Ns=%u,", ntohs (*ptr++));
    PRINTF ("Nr=%u", ntohs (*ptr++));
    cnt += 4;
  }

  if (flag_o)
  {
    pad = ntohs (*ptr++);
    ptr += pad / sizeof(*ptr);
    cnt += (2 + pad);
  }

  if (flag_t)
  {
    if (length - cnt == 0)
         PUTS (" ZLB");
    else l2tp_avp_print ((u_char *) ptr, length - cnt);
  }
  else
  {
#if 0
    PUTS (" {");
    ppp_hdlc_print ((u_char *) ptr, length - cnt);
    PUTCHAR ('}');
#else
    PUTS ("[hdlc|]");
#endif
  }
}