print-radius.c

Windump3.6.2源代码

   register u_int i;
   
   TCHECK2(data[0],length);
   
   printf("{");
   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 );

   printf("}");
   
   return;
   
   trunc:
      printf("|radius");
}  


/******************************/
/* Print an attribute numeric */
/* value pointed by 'data'    */
/* and 'length' size.         */
/******************************/
/* Returns nothing.           */
/******************************/
static void
print_attr_num(register 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)
            printf("{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 )
                printf("{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
                printf("{Unnumbered}" );
          break;
             
        case FRM_ATALK_NETWORK:
             if (EXTRACT_32BITS(data) )          
                printf("{%d}",EXTRACT_32BITS(data) );
             else
                printf("{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;
      
      } /* switch */
   
   } /* if-else */

   return;
   
   trunc:
     printf("|radius}");
}


/*****************************/
/* Print an attribute IPv4   */
/* address value pointed by  */
/* 'data' and 'length' size. */
/*****************************/
/* Returns nothing.          */
/*****************************/
static void
print_attr_address(register 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 )
              printf("{User_select}");
           else
              if (EXTRACT_32BITS(data) == 0xFFFFFFFE )
                 printf("{NAS_select}");
              else
                 printf("{%s}",ipaddr_string(data));
      break;
      
      default:
          printf("{%s}",ipaddr_string(data) );
      break;
   }
   
   return;
   
   trunc:
     printf("{|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(register 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:
     printf("{|radius}");
}

           
/***********************************/
/* Print an attribute of 'strange' */
/* data format pointed by 'data'   */
/* and 'length' size.              */
/***********************************/
/* Returns nothing.                */
/***********************************/
static void print_attr_strange(register 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;
           }
           printf("{User_challenge[");
           TCHECK2(data[0],8);
           len_data = 8;
           PRINT_HEX(len_data, data);
           printf("] User_resp[");
           TCHECK2(data[0],8);
           len_data = 8;
           PRINT_HEX(len_data, data);
           printf("]}");
        break;
        
      case ARAP_FEATURES:
           if (length != 14)
           {
               printf("{length %u != 14}", length);
               return;
           }
           TCHECK2(data[0],1);
           if (*data)
              printf("{User_can_change_pass");
           else
              printf("{User_cant_change_pass");
           data++;
           TCHECK2(data[0],1);
           printf(" Min_pass_len[%d]",*data);
           data++;
           printf(" Pass_created_at[");
           TCHECK2(data[0],4);
           len_data = 4;
           PRINT_HEX(len_data, data);
           printf("] Pass_expired_in[");
           TCHECK2(data[0],4);
           len_data = 4;
           PRINT_HEX(len_data, data);
           printf("] Current_time[");
           len_data = 4;
           TCHECK2(data[0],4);
           PRINT_HEX(len_data, data);
           printf("]}");
        break;

      case ARAP_CHALLENGE_RESP:
           if (length < 8)
           {
               printf("{length %u != 8}", length);
               return;
           }
           printf("{");
           TCHECK2(data[0],8);
           len_data = 8;
           PRINT_HEX(len_data, data);
           printf("}");
        break;
   }
   
   trunc:
     printf("|radius}");
}



static void
radius_attr_print(register u_char *attr, u_int length)
{
   register const struct radius_attr *rad_attr = (struct radius_attr *)attr;
   
   if (length < 3)
   {
      printf(" [|radius]");
      return;
   }
 
   printf(" 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
     {
        printf(" [|radius]");
        return;
     }
     length-=(rad_attr->len);
     rad_attr = (struct radius_attr *)( ((char *)(rad_attr))+rad_attr->len);
   }
   
   printf(" ]");
}


void
radius_print(const u_char *dat, u_int length)
{
   register const struct radius_hdr *rad;
   register int i;
   
   i = min(length, snapend - dat) - sizeof(*rad);

   if (i < 0) 
   {
	  printf(" [|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);  
}