_radius.c

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

  "Port_limit", NULL, 0, 0, print_attr_num}
  ,
    /*63 */
  {
  "Login_LAT_port", NULL, 0, 0, print_attr_string}
  ,
  {
  "Tunnel_type", tunnel_type, TAM_SIZE (tunnel_type) - 1, 1, print_attr_num}
  ,
  {
  "Tunnel_medium", tunnel_medium, TAM_SIZE (tunnel_medium) - 1, 1, print_attr_num}
  ,
  {
  "Tunnel_client_end", NULL, 0, 0, print_attr_string}
  ,
  {
  "Tunnel_server_end", NULL, 0, 0, print_attr_string}
  ,
  {
  "Acct_tunnel_connect", NULL, 0, 0, print_attr_string}
  ,
  {
  "Tunnel_pass", NULL, 0, 0, print_attr_string}
  ,
  {
  "ARAP_pass", NULL, 0, 0, print_attr_strange}
  ,
  {
  "ARAP_feature", NULL, 0, 0, print_attr_strange}
  ,
    /*72 */
  {
  "ARAP_zone_acces", arap_zone, TAM_SIZE (arap_zone) - 1, 1, print_attr_num}
  ,
  {
  "ARAP_security", NULL, 0, 0, print_attr_string}
  ,
  {
  "ARAP_security_data", NULL, 0, 0, print_attr_string}
  ,
  {
  "Password_retry", NULL, 0, 0, print_attr_num}
  ,
  {
  "Prompt", prompt, TAM_SIZE (prompt), 0, print_attr_num}
  ,
  {
  "Connect_info", NULL, 0, 0, print_attr_string}
  ,
  {
  "Config_token", NULL, 0, 0, print_attr_string}
  ,
  {
  "EAP_msg", NULL, 0, 0, print_attr_string}
  ,
    /*80 */
  {
  "Message_auth", NULL, 0, 0, print_attr_string}
  ,
  {
  "Tunnel_priv_group", NULL, 0, 0, print_attr_string}
  ,
  {
  "Tunnel_assign_id", NULL, 0, 0, print_attr_string}
  ,
  {
  "Tunnel_pref", NULL, 0, 0, print_attr_num}
  ,
  {
  "ARAP_challenge_resp", NULL, 0, 0, print_attr_strange}
  ,
  {
  "Acct_interim_interval", NULL, 0, 0, print_attr_num}
  ,
    /*86 */
  {
  "Acct_tunnel_pack_lost", NULL, 0, 0, print_attr_num}
  ,
  {
  "NAS_port_id", NULL, 0, 0, print_attr_string}
  ,
  {
  "Framed_pool", NULL, 0, 0, print_attr_string}
  ,
  {
  "Unassigned", NULL, 0, 0, NULL}
  ,
  {
  "Tunnel_client_auth_id", NULL, 0, 0, print_attr_string}
  ,
  {
  "Tunnel_server_auth_id", NULL, 0, 0, print_attr_string}
  ,
    /*92 */
  {
  "Unassigned", NULL, 0, 0, NULL}
  ,
    /*93 */
  {
  "Unassigned", NULL, 0, 0, NULL}
};


/*****************************/
/* Print an attribute string */
/* value pointed by 'data'   */
/* and 'length' size.        */
/*****************************/
/* Returns nothing.          */
/*****************************/

static void print_attr_string (u_char * data, u_int length, u_short attr_code)
{
  u_int i;

  TCHECK2 (data[0], length);

  PUTCHAR ('{');
  switch (attr_code)
  {
    case TUNNEL_PASS:
         if (*data && (*data <= 0x1F))
            PRINTF ("Tag[%d] ", *data);
         data++;
         PRINTF ("Salt[%d] ", EXTRACT_16BITS (data));
         data += 2;
         length -= 2;
         break;
    case TUNNEL_CLIENT_END:
    case TUNNEL_SERVER_END:
    case TUNNEL_PRIV_GROUP:
    case TUNNEL_ASSIGN_ID:
    case TUNNEL_CLIENT_AUTH:
    case TUNNEL_SERVER_AUTH:
         if (*data <= 0x1F)
         {
           PRINTF ("Tag[%d] ", *data);
           data++;
           length--;
         }
         break;
  }

  for (i = 0; i < length; i++, data++)
      PRINTF ("%c", (*data < 32 || *data > 128) ? '.' : *data);

  PUTCHAR ('}');
  return;

trunc:
  PUTS ("|radius");
}


/******************************/
/* Print an attribute numeric */
/* value pointed by 'data'    */
/* and 'length' size.         */
/******************************/
/* Returns nothing.           */
/******************************/

static void print_attr_num (u_char * data, u_int length, u_short attr_code)
{
  u_int8_t  tag;
  u_int32_t timeout;

  if (length != 4)
  {
    PRINTF ("{length %u != 4}", length);
    return;
  }

  TCHECK2 (data[0], 4);
  /* This attribute has standard values */
  if (attr_type[attr_code].siz_subtypes)
  {
    static const char **table;
    u_int32_t data_value;

    table = attr_type[attr_code].subtypes;

    if ((attr_code == TUNNEL_TYPE) || (attr_code == TUNNEL_MEDIUM))
    {
      if (!*data)
           PUTS ("{Tag[Unused]");
      else PRINTF ("{Tag[%d]", *data);
      data++;
      data_value = EXTRACT_24BITS (data);
    }
    else
    {
      data++;
      data_value = EXTRACT_32BITS (data);
    }
    if (data_value <= (attr_type[attr_code].siz_subtypes - 1 +
                       attr_type[attr_code].first_subtype))
         PRINTF ("{%s}", table[data_value]);
    else PRINTF ("{#%d}", data_value);
  }
  else
  {
    switch (attr_code)          /* Be aware of special cases... */
    {
      case FRM_IPX:
           if (EXTRACT_32BITS (data) == 0xFFFFFFFE)
                PUTS ("{NAS_select}");
           else PRINTF ("{%d}", EXTRACT_32BITS (data));
           break;

      case SESSION_TIMEOUT:
      case IDLE_TIMEOUT:
      case ACCT_DELAY:
      case ACCT_SESSION_TIME:
      case ACCT_INT_INTERVAL:
           timeout = EXTRACT_32BITS (data);
           if (timeout < 60)
              PRINTF ("{%02d secs}", timeout);
           else
           {
             if (timeout < 3600)
                  PRINTF ("{%02d:%02d min}", timeout / 60, timeout % 60);
             else PRINTF ("{%02d:%02d:%02d hours}",
                          timeout / 3600, (timeout % 3600) / 60,
                          timeout % 60);
           }
           break;

      case FRM_ATALK_LINK:
           if (EXTRACT_32BITS (data))
                PRINTF ("{%d}", EXTRACT_32BITS (data));
           else PUTS ("{Unnumbered}");
           break;

      case FRM_ATALK_NETWORK:
           if (EXTRACT_32BITS (data))
                PRINTF ("{%d}", EXTRACT_32BITS (data));
           else PUTS ("{NAS_assign}");
           break;

      case TUNNEL_PREFERENCE:
           tag = *data;
           data++;
           if (tag == 0)
                PRINTF ("{Tag[Unused] %d}", EXTRACT_24BITS (data));
           else PRINTF ("{Tag[%d] %d}", tag, EXTRACT_24BITS (data));
           break;

      default:
           PRINTF ("{%d}", EXTRACT_32BITS (data));
           break;
    }  
  }
  return;

trunc:
  PUTS ("|radius}");
}


/*****************************/
/* Print an attribute IPv4   */
/* address value pointed by  */
/* 'data' and 'length' size. */
/*****************************/
/* Returns nothing.          */
/*****************************/

static void print_attr_address (u_char * data, u_int length, u_short attr_code)
{
  if (length != 4)
  {
    PRINTF ("{length %u != 4}", length);
    return;
  }

  TCHECK2 (data[0], 4);

  switch (attr_code)
  {
    case FRM_IPADDR:
    case LOG_IPHOST:
         if (EXTRACT_32BITS (data) == 0xFFFFFFFF)
            PUTS ("{User_select}");
         else if (EXTRACT_32BITS (data) == 0xFFFFFFFE)
            PUTS ("{NAS_select}");
         else
            PRINTF ("{%s}", ipaddr_string (data));
         break;

    default:
         PRINTF ("{%s}", ipaddr_string (data));
         break;
  }

  return;

trunc:
  PUTS ("{|radius}");
}


/*************************************/
/* Print an attribute of 'secs since */
/* January 1, 1970 00:00 UTC' value  */
/* pointed by 'data' and 'length'    */
/* size.                             */
/*************************************/
/* Returns nothing.                  */
/*************************************/

static void print_attr_time (u_char * data, u_int length, u_short attr_code)
{
  time_t attr_time;
  char string[26];

  if (length != 4)
  {
    PRINTF ("{length %u != 4}", length);
    return;
  }

  TCHECK2 (data[0], 4);

  attr_time = EXTRACT_32BITS (data);
  strcpy (string, ctime (&attr_time));
  /* Get rid of the newline */
  string[24] = '\0';
  PRINTF ("{%.24s}", string);
  return;

trunc:
  PUTS ("{|radius}");
}


/***********************************/
/* Print an attribute of 'strange' */
/* data format pointed by 'data'   */
/* and 'length' size.              */
/***********************************/
/* Returns nothing.                */
/***********************************/

static void print_attr_strange (u_char * data, u_int length, u_short attr_code)
{
  u_short len_data;

  switch (attr_code)
  {
    case ARAP_PASS:
         if (length != 16)
         {
           PRINTF ("{length %u != 16}", length);
           return;
         }
         PUTS ("{User_challenge[");
         TCHECK2 (data[0], 8);
         len_data = 8;
         PRINT_HEX (len_data, data);
         PUTS ("] User_resp[");
         TCHECK2 (data[0], 8);
         len_data = 8;
         PRINT_HEX (len_data, data);
         PUTS ("]}");
         break;

    case ARAP_FEATURES:
         if (length != 14)
         {
           PRINTF ("{length %u != 14}", length);
           return;
         }
         TCHECK2 (data[0], 1);
         if (*data)
              PUTS ("{User_can_change_pass");
         else PUTS ("{User_cant_change_pass");
         data++;
         TCHECK2 (data[0], 1);
         PRINTF (" Min_pass_len[%d]", *data);
         data++;
         PUTS (" Pass_created_at[");
         TCHECK2 (data[0], 4);
         len_data = 4;
         PRINT_HEX (len_data, data);
         PUTS ("] Pass_expired_in[");
         TCHECK2 (data[0], 4);
         len_data = 4;
         PRINT_HEX (len_data, data);
         PUTS ("] Current_time[");
         len_data = 4;
         TCHECK2 (data[0], 4);
         PRINT_HEX (len_data, data);
         PUTS ("]}");
         break;

    case ARAP_CHALLENGE_RESP:
         if (length < 8)
         {
           PRINTF ("{length %u != 8}", length);
           return;
         }
         PUTS ("{");
         TCHECK2 (data[0], 8);
         len_data = 8;
         PRINT_HEX (len_data, data);
         PUTCHAR ('}');
         break;
  }

trunc:
  PUTS ("|radius}");
}



static void radius_attr_print (u_char * attr, u_int length)
{
  const struct radius_attr *rad_attr = (struct radius_attr *) attr;

  if (length < 3)
  {
    PUTS (" [|radius]");
    return;
  }

  PUTS (" Attr[ ");
  while (length > 0)
  {
    if (rad_attr->len <= length)
    {
      if (!rad_attr->type || (rad_attr->type > (TAM_SIZE (attr_type) - 1)))
        PRINTF ("#%d", rad_attr->type);
      else
      {
        PRINTF (" %s", attr_type[rad_attr->type].name);

        if (rad_attr->len > 2)
        {
          if (attr_type[rad_attr->type].print_func)
            (*attr_type[rad_attr->type].print_func) (((u_char*)(rad_attr+1)),
               rad_attr->len - 2, rad_attr->type);
        }
      }
    }
    else
    {
      PUTS (" [|radius]");
      return;
    }
    length -= (rad_attr->len);
    rad_attr = (struct radius_attr *) (((char*) (rad_attr)) + rad_attr->len);
  }
  PUTS (" ]");
}


void radius_print (const u_char * dat, u_int length)
{
  const struct radius_hdr *rad;
  int   i;

  i = min (length, snapend - dat) - sizeof(*rad);

  if (i < 0)
  {
    PUTS (" [|radius]");
    return;
  }

  rad = (struct radius_hdr *) dat;

  switch (rad->code)
  {
    case RADCMD_ACCESS_REQ:
         PRINTF (" rad-access-req %d", length);
         break;

    case RADCMD_ACCESS_ACC:
         PRINTF (" rad-access-accept %d", length);
         break;

    case RADCMD_ACCESS_REJ:
         PRINTF (" rad-access-reject %d", length);
         break;

    case RADCMD_ACCOUN_REQ:
         PRINTF (" rad-account-req %d", length);
         break;

    case RADCMD_ACCOUN_RES:
         PRINTF (" rad-account-resp %d", length);
         break;

    case RADCMD_ACCESS_CHA:
         PRINTF (" rad-access-cha %d", length);
         break;

    case RADCMD_STATUS_SER:
         PRINTF (" rad-status-serv %d", length);
         break;

    case RADCMD_STATUS_CLI:
         PRINTF (" rad-status-cli %d", length);
         break;

    case RADCMD_RESERVED:
         PRINTF (" rad-reserved %d", length);
         break;

    default:
         PRINTF (" rad-#%d %d", rad->code, length);
         break;
  }
  PRINTF (" [id %d]", rad->id);

  if (i)
     radius_attr_print (((u_char *) (rad + 1)), i);
}