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