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

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