The Tcpdump Group git mirrors - tcpdump/blob - print-radius.c

   1 /*
   2  * Copyright (C) 2000 Alfredo Andres Omella.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   8  *   1. Redistributions of source code must retain the above copyright
   9  *      notice, this list of conditions and the following disclaimer.
  10  *   2. Redistributions in binary form must reproduce the above copyright
  11  *      notice, this list of conditions and the following disclaimer in
  12  *      the documentation and/or other materials provided with the
  13  *      distribution.
  14  *   3. The names of the authors may not be used to endorse or promote
  15  *      products derived from this software without specific prior
  16  *      written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  19  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  21  */
  22 /*
  23  * Radius printer routines as specified on:
  24  *
  25  * RFC 2865:
  26  *      "Remote Authentication Dial In User Service (RADIUS)"
  27  *
  28  * RFC 2866:
  29  *      "RADIUS Accounting"
  30  *
  31  * RFC 2867:
  32  *      "RADIUS Accounting Modifications for Tunnel Protocol Support"
  33  *
  34  * RFC 2868:
  35  *      "RADIUS Attributes for Tunnel Protocol Support"
  36  *
  37  * RFC 2869:
  38  *      "RADIUS Extensions"
  39  *
  40  * Alfredo Andres Omella (aandres@s21sec.com) v0.1 2000/09/15
  41  *
  42  * TODO: Among other things to print ok MacIntosh and Vendor values
  43  */
  44
  45 #ifndef lint
  46 static const char rcsid[] =
  47     "$Id: print-radius.c,v 1.19 2002-12-11 07:14:07 guy Exp $";
  48 #endif
  49
  50 #ifdef HAVE_CONFIG_H
  51 #include "config.h"
  52 #endif
  53
  54 #include <tcpdump-stdinc.h>
  55
  56 #include <string.h>
  57
  58 #include <stdio.h>
  59
  60 #include "interface.h"
  61 #include "addrtoname.h"
  62 #include "extract.h"
  63
  64 #define TAM_SIZE(x) (sizeof(x)/sizeof(x[0]) )
  65
  66 #define PRINT_HEX(bytes_len, ptr_data)                               \
  67            while(bytes_len)                                          \
  68            {                                                         \
  69               printf("%02X", *ptr_data );                            \
  70               ptr_data++;                                            \
  71               bytes_len--;                                           \
  72            }
  73
  74
  75 /* Radius packet codes */
  76 #define RADCMD_ACCESS_REQ   1 /* Access-Request      */
  77 #define RADCMD_ACCESS_ACC   2 /* Access-Accept       */
  78 #define RADCMD_ACCESS_REJ   3 /* Access-Reject       */
  79 #define RADCMD_ACCOUN_REQ   4 /* Accounting-Request  */
  80 #define RADCMD_ACCOUN_RES   5 /* Accounting-Response */
  81 #define RADCMD_ACCESS_CHA  11 /* Access-Challenge    */
  82 #define RADCMD_STATUS_SER  12 /* Status-Server       */
  83 #define RADCMD_STATUS_CLI  13 /* Status-Client       */
  84 #define RADCMD_RESERVED   255 /* Reserved            */
  85
  86
  87 /********************************/
  88 /* Begin Radius Attribute types */
  89 /********************************/
  90 #define SERV_TYPE    6
  91 #define FRM_IPADDR   8
  92 #define LOG_IPHOST  14
  93 #define LOG_SERVICE 15
  94 #define FRM_IPX     23
  95 #define SESSION_TIMEOUT   27
  96 #define IDLE_TIMEOUT      28
  97 #define FRM_ATALK_LINK    37
  98 #define FRM_ATALK_NETWORK 38
  99
 100 #define ACCT_DELAY        41
 101 #define ACCT_SESSION_TIME 46
 102
 103 #define TUNNEL_TYPE        64
 104 #define TUNNEL_MEDIUM      65
 105 #define TUNNEL_CLIENT_END  66
 106 #define TUNNEL_SERVER_END  67
 107 #define TUNNEL_PASS        69
 108
 109 #define ARAP_PASS          70
 110 #define ARAP_FEATURES      71
 111
 112 #define TUNNEL_PRIV_GROUP  81
 113 #define TUNNEL_ASSIGN_ID   82
 114 #define TUNNEL_PREFERENCE  83
 115
 116 #define ARAP_CHALLENGE_RESP 84
 117 #define ACCT_INT_INTERVAL   85
 118
 119 #define TUNNEL_CLIENT_AUTH 90
 120 #define TUNNEL_SERVER_AUTH 91
 121 /********************************/
 122 /* End Radius Attribute types */
 123 /********************************/
 124
 125
 126 static void print_attr_string(register u_char *, u_int, u_short );
 127 static void print_attr_num(register u_char *, u_int, u_short );
 128 static void print_attr_address(register u_char *, u_int, u_short);
 129 static void print_attr_time(register u_char *, u_int, u_short);
 130 static void print_attr_strange(register u_char *, u_int, u_short);
 131
 132
 133 struct radius_hdr { u_int8_t  code; /* Radius packet code  */
 134                     u_int8_t  id;   /* Radius packet id    */
 135                     u_int16_t len;  /* Radius total length */
 136                     u_int8_t  auth[16]; /* Authenticator   */
 137                   };
 138
 139 #define MIN_RADIUS_LEN  20
 140
 141 struct radius_attr { u_int8_t type; /* Attribute type   */
 142                      u_int8_t len;  /* Attribute length */
 143                    };
 144
 145
 146 /* Service-Type Attribute standard values */
 147 static const char *serv_type[]={ NULL,
 148                                 "Login",
 149                                 "Framed",
 150                                 "Callback Login",
 151                                 "Callback Framed",
 152                                 "Outbound",
 153                                 "Administrative",
 154                                 "NAS Prompt",
 155                                 "Authenticate Only",
 156                                 "Callback NAS Prompt",
 157                                 "Call Check",
 158                                 "Callback Administrative",
 159                                };
 160
 161 /* Framed-Protocol Attribute standard values */
 162 static const char *frm_proto[]={ NULL,
 163                                  "PPP",
 164                                  "SLIP",
 165                                  "ARAP",
 166                                  "Gandalf proprietary",
 167                                  "Xylogics IPX/SLIP",
 168                                  "X.75 Synchronous",
 169                                };
 170
 171 /* Framed-Routing Attribute standard values */
 172 static const char *frm_routing[]={ "None",
 173                                    "Send",
 174                                    "Listen",
 175                                    "Send&Listen",
 176                                  };
 177
 178 /* Framed-Compression Attribute standard values */
 179 static const char *frm_comp[]={ "None",
 180                                 "VJ TCP/IP",
 181                                 "IPX",
 182                                 "Stac-LZS",
 183                               };
 184
 185 /* Login-Service Attribute standard values */
 186 static const char *login_serv[]={ "Telnet",
 187                                   "Rlogin",
 188                                   "TCP Clear",
 189                                   "PortMaster(proprietary)",
 190                                   "LAT",
 191                                   "X.25-PAD",
 192                                   "X.25-T3POS",
 193                                   "Unassigned",
 194                                   "TCP Clear Quiet",
 195                                 };
 196
 197
 198 /* Termination-Action Attribute standard values */
 199 static const char *term_action[]={ "Default",
 200                                    "RADIUS-Request",
 201                                  };
 202
 203 /* NAS-Port-Type Attribute standard values */
 204 static const char *nas_port_type[]={ "Async",
 205                                      "Sync",
 206                                      "ISDN Sync",
 207                                      "ISDN Async V.120",
 208                                      "ISDN Async V.110",
 209                                      "Virtual",
 210                                      "PIAFS",
 211                                      "HDLC Clear Channel",
 212                                      "X.25",
 213                                      "X.75",
 214                                      "G.3 Fax",
 215                                      "SDSL",
 216                                      "ADSL-CAP",
 217                                      "ADSL-DMT",
 218                                      "ISDN-DSL",
 219                                      "Ethernet",
 220                                      "xDSL",
 221                                      "Cable",
 222                                      "Wireless - Other",
 223                                      "Wireless - IEEE 802.11",
 224                                    };
 225
 226 /* Acct-Status-Type Accounting Attribute standard values */
 227 static const char *acct_status[]={ NULL,
 228                                    "Start",
 229                                    "Stop",
 230                                    "Interim-Update",
 231                                    "Unassigned",
 232                                    "Unassigned",
 233                                    "Unassigned",
 234                                    "Accounting-On",
 235                                    "Accounting-Off",
 236                                    "Tunnel-Start",
 237                                    "Tunnel-Stop",
 238                                    "Tunnel-Reject",
 239                                    "Tunnel-Link-Start",
 240                                    "Tunnel-Link-Stop",
 241                                    "Tunnel-Link-Reject",
 242                                    "Failed",
 243                                  };
 244
 245 /* Acct-Authentic Accounting Attribute standard values */
 246 static const char *acct_auth[]={ NULL,
 247                                  "RADIUS",
 248                                  "Local",
 249                                  "Remote",
 250                                };
 251
 252 /* Acct-Terminate-Cause Accounting Attribute standard values */
 253 static const char *acct_term[]={ NULL,
 254                                  "User Request",
 255                                  "Lost Carrier",
 256                                  "Lost Service",
 257                                  "Idle Timeout",
 258                                  "Session Timeout",
 259                                  "Admin Reset",
 260                                  "Admin Reboot",
 261                                  "Port Error",
 262                                  "NAS Error",
 263                                  "NAS Request",
 264                                  "NAS Reboot",
 265                                  "Port Unneeded",
 266                                  "Port Preempted",
 267                                  "Port Suspended",
 268                                  "Service Unavailable",
 269                                  "Callback",
 270                                  "User Error",
 271                                  "Host Request",
 272                                };
 273
 274 /* Tunnel-Type Attribute standard values */
 275 static const char *tunnel_type[]={ NULL,
 276                                    "PPTP",
 277                                    "L2F",
 278                                    "L2TP",
 279                                    "ATMP",
 280                                    "VTP",
 281                                    "AH",
 282                                    "IP-IP",
 283                                    "MIN-IP-IP",
 284                                    "ESP",
 285                                    "GRE",
 286                                    "DVS",
 287                                    "IP-in-IP Tunneling",
 288                                  };
 289
 290 /* Tunnel-Medium-Type Attribute standard values */
 291 static const char *tunnel_medium[]={ NULL,
 292                                      "IPv4",
 293                                      "IPv6",
 294                                      "NSAP",
 295                                      "HDLC",
 296                                      "BBN 1822",
 297                                      "802",
 298                                      "E.163",
 299                                      "E.164",
 300                                      "F.69",
 301                                      "X.121",
 302                                      "IPX",
 303                                      "Appletalk",
 304                                      "Decnet IV",
 305                                      "Banyan Vines",
 306                                      "E.164 with NSAP subaddress",
 307                                    };
 308
 309 /* ARAP-Zone-Access Attribute standard values */
 310 static const char *arap_zone[]={ NULL,
 311                                  "Only access to dfl zone",
 312                                  "Use zone filter inc.",
 313                                  "Not used",
 314                                  "Use zone filter exc.",
 315                                };
 316
 317 static const char *prompt[]={ "No Echo",
 318                               "Echo",
 319                             };
 320
 321
 322 struct attrtype { const char *name;      /* Attribute name                 */
 323                   const char **subtypes; /* Standard Values (if any)       */
 324                   u_char siz_subtypes;   /* Size of total standard values  */
 325                   u_char first_subtype;  /* First standard value is 0 or 1 */
 326                   void (*print_func)(register u_char *, u_int, u_short );
 327                 } attr_type[]=
 328   {
 329      { NULL,             NULL, 0, 0, NULL               },
 330      { "User",           NULL, 0, 0, print_attr_string  },
 331      { "Pass",           NULL, 0, 0, NULL               },
 332      { "CHAP-Pass",      NULL, 0, 0, NULL               },
 333      { "NAS_ipaddr",     NULL, 0, 0, print_attr_address },
 334      { "NAS_port",       NULL, 0, 0, print_attr_num     },
 335      { "Service_type",   serv_type, TAM_SIZE(serv_type)-1, 1, print_attr_num },
 336      { "Framed_proto",   frm_proto, TAM_SIZE(frm_proto)-1, 1, print_attr_num },
 337      { "Framed_ipaddr",  NULL, 0, 0, print_attr_address },
 338      { "Framed_ipnet",   NULL, 0, 0, print_attr_address },
 339      { "Framed_routing", frm_routing, TAM_SIZE(frm_routing), 0,
 340                                                               print_attr_num },
 341      { "Filter_id",      NULL, 0, 0, print_attr_string  },
 342      { "Framed_mtu",     NULL, 0, 0, print_attr_num     },
 343      { "Framed_compress",  frm_comp, TAM_SIZE(frm_comp),   0, print_attr_num },
 344      { "Login_iphost",   NULL, 0, 0, print_attr_address },
 345      { "Login_service",  login_serv, TAM_SIZE(login_serv), 0, print_attr_num },
 346      { "Login_TCP_port", NULL, 0, 0, print_attr_num     },
 347 /*17*/ { "Unassigned", NULL, 0, 0, NULL },
 348      { "Reply",           NULL, 0, 0, print_attr_string },
 349      { "Callback-number", NULL, 0, 0, print_attr_string },
 350      { "Callback-id",     NULL, 0, 0, print_attr_string },
 351 /*21*/ { "Unassigned", NULL, 0, 0, NULL },
 352      { "Framed_route",      NULL, 0, 0, print_attr_string },
 353      { "Framed_ipx_net",    NULL, 0, 0, print_attr_num    },
 354      { "State",             NULL, 0, 0, print_attr_string },
 355      { "Class",             NULL, 0, 0, print_attr_string },
 356      { "Vendor_specific",   NULL, 0, 0, print_attr_string },
 357      { "Session_timeout",   NULL, 0, 0, print_attr_num    },
 358      { "Idle_timeout",      NULL, 0, 0, print_attr_num    },
 359      { "Term_action", term_action, TAM_SIZE(term_action), 0, print_attr_num },
 360      { "Called_station",    NULL, 0, 0, print_attr_string },
 361      { "Calling_station",   NULL, 0, 0, print_attr_string },
 362      { "NAS_id",            NULL, 0, 0, print_attr_string },
 363      { "Proxy_state",       NULL, 0, 0, print_attr_string },
 364      { "Login_LAT_service", NULL, 0, 0, print_attr_string },
 365      { "Login_LAT_node",    NULL, 0, 0, print_attr_string },
 366      { "Login_LAT_group",   NULL, 0, 0, print_attr_string },
 367      { "Framed_atalk_link", NULL, 0, 0, print_attr_num    },
 368      { "Framed_atalk_net",  NULL, 0, 0, print_attr_num    },
 369      { "Framed_atalk_zone", NULL, 0, 0, print_attr_string },
 370      { "Acct_status", acct_status, TAM_SIZE(acct_status)-1, 1, print_attr_num },
 371      { "Acct_delay",        NULL, 0, 0, print_attr_num    },
 372      { "Acct_in_octets",    NULL, 0, 0, print_attr_num    },
 373      { "Acct_out_octets",   NULL, 0, 0, print_attr_num    },
 374      { "Acct_session_id",   NULL, 0, 0, print_attr_string },
 375      { "Acct_authentic",  acct_auth, TAM_SIZE(acct_auth)-1, 1, print_attr_num },
 376      { "Acct_session_time", NULL, 0, 0, print_attr_num },
 377      { "Acct_in_packets",   NULL, 0, 0, print_attr_num },
 378      { "Acct_out_packets",  NULL, 0, 0, print_attr_num },
 379      { "Acct_term_cause", acct_term, TAM_SIZE(acct_term)-1, 1, print_attr_num },
 380      { "Acct_multi_session_id", NULL, 0, 0, print_attr_string },
 381      { "Acct_link_count", NULL, 0, 0, print_attr_num },
 382      { "Acct_in_giga",    NULL, 0, 0, print_attr_num },
 383      { "Acct_out_giga",   NULL, 0, 0, print_attr_num },
 384 /*54*/ { "Unassigned", NULL, 0, 0, NULL },
 385      { "Event_timestamp", NULL, 0, 0, print_attr_time },
 386 /*56*/ { "Unassigned", NULL, 0, 0, NULL },
 387 /*57*/ { "Unassigned", NULL, 0, 0, NULL },
 388 /*58*/ { "Unassigned", NULL, 0, 0, NULL },
 389 /*59*/ { "Unassigned", NULL, 0, 0, NULL },
 390      { "CHAP_challenge", NULL, 0, 0, print_attr_string },
 391      { "NAS_port_type",  nas_port_type, TAM_SIZE(nas_port_type), 0,
 392                                                               print_attr_num },
 393      { "Port_limit",     NULL, 0, 0, print_attr_num },
 394 /*63*/ { "Login_LAT_port", NULL, 0, 0, print_attr_string },
 395      { "Tunnel_type", tunnel_type, TAM_SIZE(tunnel_type)-1, 1, print_attr_num },
 396      { "Tunnel_medium", tunnel_medium, TAM_SIZE(tunnel_medium)-1, 1,
 397                                                              print_attr_num },
 398      { "Tunnel_client_end",   NULL, 0, 0, print_attr_string },
 399      { "Tunnel_server_end",   NULL, 0, 0, print_attr_string },
 400      { "Acct_tunnel_connect", NULL, 0, 0, print_attr_string },
 401      { "Tunnel_pass",  NULL, 0, 0, print_attr_string  },
 402      { "ARAP_pass",    NULL, 0, 0, print_attr_strange },
 403      { "ARAP_feature", NULL, 0, 0, print_attr_strange },
 404 /*72*/ { "ARAP_zone_acces", arap_zone, TAM_SIZE(arap_zone)-1, 1,
 405                                                              print_attr_num },
 406      { "ARAP_security",      NULL, 0, 0, print_attr_string },
 407      { "ARAP_security_data", NULL, 0, 0, print_attr_string },
 408      { "Password_retry",     NULL, 0, 0, print_attr_num    },
 409      { "Prompt", prompt, TAM_SIZE(prompt), 0, print_attr_num },
 410      { "Connect_info",       NULL, 0, 0, print_attr_string   },
 411      { "Config_token",       NULL, 0, 0, print_attr_string   },
 412      { "EAP_msg",            NULL, 0, 0, print_attr_string   },
 413 /*80*/ { "Message_auth",    NULL, 0, 0, print_attr_string },
 414      { "Tunnel_priv_group", NULL, 0, 0, print_attr_string },
 415      { "Tunnel_assign_id",  NULL, 0, 0, print_attr_string },
 416      { "Tunnel_pref",       NULL, 0, 0, print_attr_num    },
 417      { "ARAP_challenge_resp",    NULL, 0, 0, print_attr_strange },
 418      { "Acct_interim_interval",  NULL, 0, 0, print_attr_num     },
 419 /*86*/ { "Acct_tunnel_pack_lost",  NULL, 0, 0, print_attr_num },
 420      { "NAS_port_id", NULL, 0, 0, print_attr_string },
 421      { "Framed_pool", NULL, 0, 0, print_attr_string },
 422      { "Unassigned",  NULL, 0, 0, NULL },
 423      { "Tunnel_client_auth_id", NULL, 0, 0, print_attr_string },
 424      { "Tunnel_server_auth_id", NULL, 0, 0, print_attr_string },
 425 /*92*/ { "Unassigned",  NULL, 0, 0, NULL },
 426 /*93*/ { "Unassigned",  NULL, 0, 0, NULL }
 427   };
 428
 429
 430 /*****************************/
 431 /* Print an attribute string */
 432 /* value pointed by 'data'   */
 433 /* and 'length' size.        */
 434 /*****************************/
 435 /* Returns nothing.          */
 436 /*****************************/
 437 static void
 438 print_attr_string(register u_char *data, u_int length, u_short attr_code )
 439 {
 440    register u_int i;
 441
 442    TCHECK2(data[0],length);
 443
 444    printf("{");
 445    switch(attr_code)
 446    {
 447       case TUNNEL_PASS:
 448            if (*data && (*data <=0x1F) )
 449               printf("Tag[%d] ",*data);
 450            data++;
 451            printf("Salt[%d] ",EXTRACT_16BITS(data) );
 452            data+=2;
 453            length-=2;
 454         break;
 455       case TUNNEL_CLIENT_END:
 456       case TUNNEL_SERVER_END:
 457       case TUNNEL_PRIV_GROUP:
 458       case TUNNEL_ASSIGN_ID:
 459       case TUNNEL_CLIENT_AUTH:
 460       case TUNNEL_SERVER_AUTH:
 461            if (*data <= 0x1F)
 462            {
 463               printf("Tag[%d] ",*data);
 464               data++;
 465               length--;
 466            }
 467         break;
 468    }
 469
 470    for (i=0; i < length ; i++, data++)
 471        printf("%c",(*data < 32 || *data > 128) ? '.' : *data );
 472
 473    printf("}");
 474
 475    return;
 476
 477    trunc:
 478       printf("|radius");
 479 }
 480
 481
 482 /******************************/
 483 /* Print an attribute numeric */
 484 /* value pointed by 'data'    */
 485 /* and 'length' size.         */
 486 /******************************/
 487 /* Returns nothing.           */
 488 /******************************/
 489 static void
 490 print_attr_num(register u_char *data, u_int length, u_short attr_code )
 491 {
 492    u_int8_t tag;
 493    u_int32_t timeout;
 494
 495    if (length != 4)
 496    {
 497        printf("{length %u != 4}", length);
 498        return;
 499    }
 500
 501    TCHECK2(data[0],4);
 502                           /* This attribute has standard values */
 503    if (attr_type[attr_code].siz_subtypes)
 504    {
 505       static const char **table;
 506       u_int32_t data_value;
 507       table = attr_type[attr_code].subtypes;
 508
 509       if ( (attr_code == TUNNEL_TYPE) || (attr_code == TUNNEL_MEDIUM) )
 510       {
 511          if (!*data)
 512             printf("{Tag[Unused]");
 513          else
 514             printf("{Tag[%d]", *data);
 515          data++;
 516          data_value = EXTRACT_24BITS(data);
 517       }
 518       else
 519       {
 520          data_value = EXTRACT_32BITS(data);
 521       }
 522       if ( data_value <= (u_int32_t)(attr_type[attr_code].siz_subtypes - 1 +
 523             attr_type[attr_code].first_subtype) &&
 524            data_value >= attr_type[attr_code].first_subtype )
 525          printf("{%s}",table[data_value]);
 526       else
 527          printf("{#%u}",data_value);
 528    }
 529    else
 530    {
 531       switch(attr_code) /* Be aware of special cases... */
 532       {
 533         case FRM_IPX:
 534              if (EXTRACT_32BITS( data) == 0xFFFFFFFE )
 535                 printf("{NAS_select}");
 536              else
 537                 printf("{%d}",EXTRACT_32BITS( data) );
 538           break;
 539
 540         case SESSION_TIMEOUT:
 541         case IDLE_TIMEOUT:
 542         case ACCT_DELAY:
 543         case ACCT_SESSION_TIME:
 544         case ACCT_INT_INTERVAL:
 545              timeout = EXTRACT_32BITS( data);
 546              if ( timeout < 60 )
 547                 printf( "{%02d secs}", timeout);
 548              else
 549              {
 550                 if ( timeout < 3600 )
 551                    printf( "{%02d:%02d min}",
 552                           timeout / 60, timeout % 60);
 553                 else
 554                    printf( "{%02d:%02d:%02d hours}",
 555                           timeout / 3600, (timeout % 3600) / 60,
 556                           timeout % 60);
 557              }
 558           break;
 559
 560         case FRM_ATALK_LINK:
 561              if (EXTRACT_32BITS(data) )
 562                 printf("{%d}",EXTRACT_32BITS(data) );
 563              else
 564                 printf("{Unnumbered}" );
 565           break;
 566
 567         case FRM_ATALK_NETWORK:
 568              if (EXTRACT_32BITS(data) )
 569                 printf("{%d}",EXTRACT_32BITS(data) );
 570              else
 571                 printf("{NAS_assign}" );
 572           break;
 573
 574         case TUNNEL_PREFERENCE:
 575             tag = *data;
 576             data++;
 577             if (tag == 0)
 578                printf("{Tag[Unused] %d}",EXTRACT_24BITS(data) );
 579             else
 580                printf("{Tag[%d] %d}", tag, EXTRACT_24BITS(data) );
 581           break;
 582
 583         default:
 584              printf("{%d}",EXTRACT_32BITS( data) );
 585           break;
 586
 587       } /* switch */
 588
 589    } /* if-else */
 590
 591    return;
 592
 593    trunc:
 594      printf("|radius}");
 595 }
 596
 597
 598 /*****************************/
 599 /* Print an attribute IPv4   */
 600 /* address value pointed by  */
 601 /* 'data' and 'length' size. */
 602 /*****************************/
 603 /* Returns nothing.          */
 604 /*****************************/
 605 static void
 606 print_attr_address(register u_char *data, u_int length, u_short attr_code )
 607 {
 608    if (length != 4)
 609    {
 610        printf("{length %u != 4}", length);
 611        return;
 612    }
 613
 614    TCHECK2(data[0],4);
 615
 616    switch(attr_code)
 617    {
 618       case FRM_IPADDR:
 619       case LOG_IPHOST:
 620            if (EXTRACT_32BITS(data) == 0xFFFFFFFF )
 621               printf("{User_select}");
 622            else
 623               if (EXTRACT_32BITS(data) == 0xFFFFFFFE )
 624                  printf("{NAS_select}");
 625               else
 626                  printf("{%s}",ipaddr_string(data));
 627       break;
 628
 629       default:
 630           printf("{%s}",ipaddr_string(data) );
 631       break;
 632    }
 633
 634    return;
 635
 636    trunc:
 637      printf("{|radius}");
 638 }
 639
 640
 641 /*************************************/
 642 /* Print an attribute of 'secs since */
 643 /* January 1, 1970 00:00 UTC' value  */
 644 /* pointed by 'data' and 'length'    */
 645 /* size.                             */
 646 /*************************************/
 647 /* Returns nothing.                  */
 648 /*************************************/
 649 static void print_attr_time(register u_char *data, u_int length, u_short attr_code _U_)
 650 {
 651    time_t attr_time;
 652    char string[26];
 653
 654    if (length != 4)
 655    {
 656        printf("{length %u != 4}", length);
 657        return;
 658    }
 659
 660    TCHECK2(data[0],4);
 661
 662    attr_time = EXTRACT_32BITS(data);
 663    strlcpy(string, ctime(&attr_time), sizeof(string));
 664    /* Get rid of the newline */
 665    string[24] = '\0';
 666    printf("{%.24s}", string);
 667    return;
 668
 669    trunc:
 670      printf("{|radius}");
 671 }
 672
 673
 674 /***********************************/
 675 /* Print an attribute of 'strange' */
 676 /* data format pointed by 'data'   */
 677 /* and 'length' size.              */
 678 /***********************************/
 679 /* Returns nothing.                */
 680 /***********************************/
 681 static void print_attr_strange(register u_char *data, u_int length, u_short attr_code)
 682 {
 683    u_short len_data;
 684
 685    switch(attr_code)
 686    {
 687       case ARAP_PASS:
 688            if (length != 16)
 689            {
 690                printf("{length %u != 16}", length);
 691                return;
 692            }
 693            printf("{User_challenge[");
 694            TCHECK2(data[0],8);
 695            len_data = 8;
 696            PRINT_HEX(len_data, data);
 697            printf("] User_resp[");
 698            TCHECK2(data[0],8);
 699            len_data = 8;
 700            PRINT_HEX(len_data, data);
 701            printf("]}");
 702         break;
 703
 704       case ARAP_FEATURES:
 705            if (length != 14)
 706            {
 707                printf("{length %u != 14}", length);
 708                return;
 709            }
 710            TCHECK2(data[0],1);
 711            if (*data)
 712               printf("{User_can_change_pass");
 713            else
 714               printf("{User_cant_change_pass");
 715            data++;
 716            TCHECK2(data[0],1);
 717            printf(" Min_pass_len[%d]",*data);
 718            data++;
 719            printf(" Pass_created_at[");
 720            TCHECK2(data[0],4);
 721            len_data = 4;
 722            PRINT_HEX(len_data, data);
 723            printf("] Pass_expired_in[");
 724            TCHECK2(data[0],4);
 725            len_data = 4;
 726            PRINT_HEX(len_data, data);
 727            printf("] Current_time[");
 728            len_data = 4;
 729            TCHECK2(data[0],4);
 730            PRINT_HEX(len_data, data);
 731            printf("]}");
 732         break;
 733
 734       case ARAP_CHALLENGE_RESP:
 735            if (length < 8)
 736            {
 737                printf("{length %u != 8}", length);
 738                return;
 739            }
 740            printf("{");
 741            TCHECK2(data[0],8);
 742            len_data = 8;
 743            PRINT_HEX(len_data, data);
 744            printf("}");
 745         break;
 746    }
 747
 748    trunc:
 749      printf("|radius}");
 750 }
 751
 752
 753
 754 static void
 755 radius_attr_print(register const u_char *attr, u_int length)
 756 {
 757    register const struct radius_attr *rad_attr = (struct radius_attr *)attr;
 758
 759    if (length < 3)
 760    {
 761       printf(" [|radius]");
 762       return;
 763    }
 764
 765    printf(" Attr[ ");
 766    while (length > 0)
 767    {
 768      if (rad_attr->len == 0)
 769      {
 770         printf("(zero-length attribute)");
 771         return;
 772      }
 773      if ( rad_attr->len <= length )
 774      {
 775         if ( !rad_attr->type || (rad_attr->type > (TAM_SIZE(attr_type)-1))  )
 776            printf("#%d",rad_attr->type);
 777         else
 778         {
 779            printf(" %s",attr_type[rad_attr->type].name);
 780
 781            if (rad_attr->len > 2)
 782            {
 783                if ( attr_type[rad_attr->type].print_func )
 784                   (*attr_type[rad_attr->type].print_func)(
 785                                            ((u_char *)(rad_attr+1)),
 786                                            rad_attr->len - 2, rad_attr->type);
 787            }
 788         }
 789      }
 790      else
 791      {
 792         printf(" [|radius]");
 793         return;
 794      }
 795      length-=(rad_attr->len);
 796      rad_attr = (struct radius_attr *)( ((char *)(rad_attr))+rad_attr->len);
 797    }
 798
 799    printf(" ]");
 800 }
 801
 802
 803 void
 804 radius_print(const u_char *dat, u_int length)
 805 {
 806    register const struct radius_hdr *rad;
 807    register u_int i;
 808    u_int len;
 809
 810    if (snapend < dat)
 811    {
 812           printf(" [|radius]");
 813           return;
 814    }
 815    i = snapend - dat;
 816    if (i > length)
 817           i = length;
 818
 819    if (i < MIN_RADIUS_LEN)
 820    {
 821           printf(" [|radius]");
 822           return;
 823    }
 824
 825    rad = (struct radius_hdr *)dat;
 826    len = EXTRACT_16BITS(&rad->len);
 827
 828    if (len < MIN_RADIUS_LEN)
 829    {
 830           printf(" [|radius]");
 831           return;
 832    }
 833
 834    if (len < i)
 835           i = len;
 836
 837    i -= MIN_RADIUS_LEN;
 838
 839    switch (rad->code)
 840    {
 841      case RADCMD_ACCESS_REQ:
 842          printf(" rad-access-req %u", length);
 843          break;
 844
 845      case RADCMD_ACCESS_ACC:
 846          printf(" rad-access-accept %u", length);
 847          break;
 848
 849      case RADCMD_ACCESS_REJ:
 850          printf(" rad-access-reject %u", length);
 851          break;
 852
 853      case RADCMD_ACCOUN_REQ:
 854          printf(" rad-account-req %u", length);
 855          break;
 856
 857      case RADCMD_ACCOUN_RES:
 858          printf(" rad-account-resp %u", length);
 859          break;
 860
 861      case RADCMD_ACCESS_CHA:
 862          printf(" rad-access-cha %u", length);
 863          break;
 864
 865      case RADCMD_STATUS_SER:
 866          printf(" rad-status-serv %u", length);
 867          break;
 868
 869      case RADCMD_STATUS_CLI:
 870          printf(" rad-status-cli %u", length);
 871          break;
 872
 873      case RADCMD_RESERVED:
 874          printf(" rad-reserved %u", length);
 875          break;
 876
 877      default:
 878          printf(" rad-#%u %u", rad->code, length);
 879          break;
 880    }
 881    printf(" [id %u]", rad->id);
 882
 883    if (i)
 884       radius_attr_print( dat + MIN_RADIUS_LEN, i);
 885 }