src/main/radclient.c

   1 /*
   2  * radclient.c  General radius packet debug tool.
   3  *
   4  * Version:     $Id$
   5  *
   6  *   This program is free software; you can redistribute it and/or modify
   7  *   it under the terms of the GNU General Public License as published by
   8  *   the Free Software Foundation; either version 2 of the License, or
   9  *   (at your option) any later version.
  10  *
  11  *   This program is distributed in the hope that it will be useful,
  12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *   GNU General Public License for more details.
  15  *
  16  *   You should have received a copy of the GNU General Public License
  17  *   along with this program; if not, write to the Free Software
  18  *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  * Copyright 2000,2006  The FreeRADIUS server project
  21  * Copyright 2000  Miquel van Smoorenburg <miquels@cistron.nl>
  22  * Copyright 2000  Alan DeKok <aland@ox.org>
  23  */
  24
  25 #include <freeradius-devel/ident.h>
  26 RCSID("$Id$")
  27
  28 #include <freeradius-devel/libradius.h>
  29 #include <freeradius-devel/conf.h>
  30 #include <freeradius-devel/radpaths.h>
  31
  32 #include <ctype.h>
  33
  34 #ifdef HAVE_GETOPT_H
  35 #       include <getopt.h>
  36 #endif
  37
  38 #include <assert.h>
  39
  40 static int retries = 10;
  41 static float timeout = 3;
  42 static const char *secret = NULL;
  43 static int do_output = 1;
  44 static int totalapp = 0;
  45 static int totaldeny = 0;
  46 static int totallost = 0;
  47
  48 static int server_port = 0;
  49 static int packet_code = 0;
  50 static fr_ipaddr_t server_ipaddr;
  51 static int resend_count = 1;
  52 static int done = 1;
  53 static int print_filename = 0;
  54
  55 static fr_ipaddr_t client_ipaddr;
  56 static int client_port = 0;
  57
  58 static int sockfd;
  59 static int last_used_id = -1;
  60
  61 static rbtree_t *filename_tree = NULL;
  62 static fr_packet_list_t *pl = NULL;
  63
  64 static int sleep_time = -1;
  65
  66 typedef struct radclient_t {
  67         struct          radclient_t *prev;
  68         struct          radclient_t *next;
  69
  70         const char      *filename;
  71         int             packet_number; /* in the file */
  72         char            password[256];
  73         time_t          timestamp;
  74         RADIUS_PACKET   *request;
  75         RADIUS_PACKET   *reply;
  76         int             resend;
  77         int             tries;
  78         int             done;
  79 } radclient_t;
  80
  81 static radclient_t *radclient_head = NULL;
  82 static radclient_t *radclient_tail = NULL;
  83
  84
  85 static void NEVER_RETURNS usage(void)
  86 {
  87         fprintf(stderr, "Usage: radclient [options] server[:port] <command> [<secret>]\n");
  88
  89         fprintf(stderr, "  <command>    One of auth, acct, status, coa, or disconnect.\n");
  90         fprintf(stderr, "  -c count    Send each packet 'count' times.\n");
  91         fprintf(stderr, "  -d raddb    Set dictionary directory.\n");
  92         fprintf(stderr, "  -f file     Read packets from file, not stdin.\n");
  93         fprintf(stderr, "  -i id       Set request id to 'id'.  Values may be 0..255\n");
  94         fprintf(stderr, "  -n num      Send N requests/s\n");
  95         fprintf(stderr, "  -p num      Send 'num' packets from a file in parallel.\n");
  96         fprintf(stderr, "  -q          Do not print anything out.\n");
  97         fprintf(stderr, "  -r retries  If timeout, retry sending the packet 'retries' times.\n");
  98         fprintf(stderr, "  -s          Print out summary information of auth results.\n");
  99         fprintf(stderr, "  -S file     read secret from file, not command line.\n");
 100         fprintf(stderr, "  -t timeout  Wait 'timeout' seconds before retrying (may be a floating point number).\n");
 101         fprintf(stderr, "  -v          Show program version information.\n");
 102         fprintf(stderr, "  -x          Debugging mode.\n");
 103         fprintf(stderr, "  -4          Use IPv4 address of server\n");
 104         fprintf(stderr, "  -6          Use IPv6 address of server.\n");
 105
 106         exit(1);
 107 }
 108
 109 /*
 110  *      Free a radclient struct, which may (or may not)
 111  *      already be in the list.
 112  */
 113 static void radclient_free(radclient_t *radclient)
 114 {
 115         radclient_t *prev, *next;
 116
 117         if (radclient->request) rad_free(&radclient->request);
 118         if (radclient->reply) rad_free(&radclient->reply);
 119
 120         prev = radclient->prev;
 121         next = radclient->next;
 122
 123         if (prev) {
 124                 assert(radclient_head != radclient);
 125                 prev->next = next;
 126         } else if (radclient_head) {
 127                 assert(radclient_head == radclient);
 128                 radclient_head = next;
 129         }
 130
 131         if (next) {
 132                 assert(radclient_tail != radclient);
 133                 next->prev = prev;
 134         } else if (radclient_tail) {
 135                 assert(radclient_tail == radclient);
 136                 radclient_tail = prev;
 137         }
 138
 139         free(radclient);
 140 }
 141
 142 /*
 143  *      Initialize a radclient data structure
 144  */
 145 static radclient_t *radclient_init(const char *filename)
 146 {
 147         FILE *fp;
 148         VALUE_PAIR *vp;
 149         radclient_t *start, *radclient, *prev = NULL;
 150         int filedone = 0;
 151         int packet_number = 1;
 152
 153         start = NULL;
 154         assert(filename != NULL);
 155
 156         /*
 157          *      Determine where to read the VP's from.
 158          */
 159         if (strcmp(filename, "-") != 0) {
 160                 fp = fopen(filename, "r");
 161                 if (!fp) {
 162                         fprintf(stderr, "radclient: Error opening %s: %s\n",
 163                                 filename, strerror(errno));
 164                         return NULL;
 165                 }
 166         } else {
 167                 fp = stdin;
 168         }
 169
 170         /*
 171          *      Loop until the file is done.
 172          */
 173         do {
 174                 /*
 175                  *      Allocate it.
 176                  */
 177                 radclient = malloc(sizeof(*radclient));
 178                 if (!radclient) {
 179                         perror("radclient: X");
 180                         if (fp != stdin) fclose(fp);
 181                         return NULL; /* memory leak "start" */
 182                 }
 183                 memset(radclient, 0, sizeof(*radclient));
 184
 185                 radclient->request = rad_alloc(1);
 186                 if (!radclient->request) {
 187                         fr_perror("radclient: Y");
 188                         radclient_free(radclient);
 189                         if (fp != stdin) fclose(fp);
 190                         return NULL; /* memory leak "start" */
 191                 }
 192
 193                 radclient->filename = filename;
 194                 radclient->request->id = -1; /* allocate when sending */
 195                 radclient->packet_number = packet_number++;
 196
 197                 /*
 198                  *      Read the VP's.
 199                  */
 200                 radclient->request->vps = readvp2(fp, &filedone, "radclient:");
 201                 if (!radclient->request->vps) {
 202                         radclient_free(radclient);
 203                         if (fp != stdin) fclose(fp);
 204                         return start; /* done: return the list */
 205                 }
 206
 207                 /*
 208                  *      Keep a copy of the the User-Password attribute.
 209                  */
 210                 if ((vp = pairfind(radclient->request->vps, PW_USER_PASSWORD)) != NULL) {
 211                         strlcpy(radclient->password, vp->vp_strvalue,
 212                                 sizeof(radclient->password));
 213                         /*
 214                          *      Otherwise keep a copy of the CHAP-Password attribute.
 215                          */
 216                 } else if ((vp = pairfind(radclient->request->vps, PW_CHAP_PASSWORD)) != NULL) {
 217                         strlcpy(radclient->password, vp->vp_strvalue,
 218                                 sizeof(radclient->password));
 219                 } else {
 220                         radclient->password[0] = '\0';
 221                 }
 222
 223                 /*
 224                  *  Fix up Digest-Attributes issues
 225                  */
 226                 for (vp = radclient->request->vps; vp != NULL; vp = vp->next) {
 227                         switch (vp->attribute) {
 228                         default:
 229                                 break;
 230
 231                                 /*
 232                                  *      Allow it to set the packet type in
 233                                  *      the attributes read from the file.
 234                                  */
 235                         case PW_PACKET_TYPE:
 236                                 radclient->request->code = vp->vp_integer;
 237                                 break;
 238
 239                         case PW_PACKET_DST_PORT:
 240                                 radclient->request->dst_port = (vp->vp_integer & 0xffff);
 241                                 break;
 242
 243                         case PW_PACKET_DST_IP_ADDRESS:
 244                                 radclient->request->dst_ipaddr.af = AF_INET;
 245                                 radclient->request->dst_ipaddr.ipaddr.ip4addr.s_addr = vp->vp_ipaddr;
 246                                 break;
 247
 248                         case PW_PACKET_DST_IPV6_ADDRESS:
 249                                 radclient->request->dst_ipaddr.af = AF_INET6;
 250                                 radclient->request->dst_ipaddr.ipaddr.ip6addr = vp->vp_ipv6addr;
 251                                 break;
 252
 253                         case PW_PACKET_SRC_PORT:
 254                                 radclient->request->src_port = (vp->vp_integer & 0xffff);
 255                                 break;
 256
 257                         case PW_PACKET_SRC_IP_ADDRESS:
 258                                 radclient->request->src_ipaddr.af = AF_INET;
 259                                 radclient->request->src_ipaddr.ipaddr.ip4addr.s_addr = vp->vp_ipaddr;
 260                                 break;
 261
 262                         case PW_PACKET_SRC_IPV6_ADDRESS:
 263                                 radclient->request->src_ipaddr.af = AF_INET6;
 264                                 radclient->request->src_ipaddr.ipaddr.ip6addr = vp->vp_ipv6addr;
 265                                 break;
 266
 267                         case PW_DIGEST_REALM:
 268                         case PW_DIGEST_NONCE:
 269                         case PW_DIGEST_METHOD:
 270                         case PW_DIGEST_URI:
 271                         case PW_DIGEST_QOP:
 272                         case PW_DIGEST_ALGORITHM:
 273                         case PW_DIGEST_BODY_DIGEST:
 274                         case PW_DIGEST_CNONCE:
 275                         case PW_DIGEST_NONCE_COUNT:
 276                         case PW_DIGEST_USER_NAME:
 277                                 /* overlapping! */
 278                                 memmove(&vp->vp_octets[2], &vp->vp_octets[0],
 279                                         vp->length);
 280                                 vp->vp_octets[0] = vp->attribute - PW_DIGEST_REALM + 1;
 281                                 vp->length += 2;
 282                                 vp->vp_octets[1] = vp->length;
 283                                 vp->attribute = PW_DIGEST_ATTRIBUTES;
 284                                 break;
 285                         }
 286                 } /* loop over the VP's we read in */
 287
 288                 if (!start) {
 289                         start = radclient;
 290                         prev = start;
 291                 } else {
 292                         prev->next = radclient;
 293                         radclient->prev = prev;
 294                         prev = radclient;
 295                 }
 296         } while (!filedone); /* loop until the file is done. */
 297
 298         if (fp != stdin) fclose(fp);
 299
 300         /*
 301          *      And we're done.
 302          */
 303         return start;
 304 }
 305
 306
 307 /*
 308  *      Sanity check each argument.
 309  */
 310 static int radclient_sane(radclient_t *radclient)
 311 {
 312         if (radclient->request->dst_port == 0) {
 313                 radclient->request->dst_port = server_port;
 314         }
 315         if (radclient->request->dst_ipaddr.af == AF_UNSPEC) {
 316                 if (server_ipaddr.af == AF_UNSPEC) {
 317                         fprintf(stderr, "radclient: No server was given, but request %d in file %s did not contain Packet-Dst-IP-Address\n",
 318                                 radclient->packet_number, radclient->filename);
 319                         return -1;
 320                 }
 321                 radclient->request->dst_ipaddr = server_ipaddr;
 322         }
 323         if (radclient->request->code == 0) {
 324                 if (packet_code == -1) {
 325                         fprintf(stderr, "radclient: Request was \"auto\", but request %d in file %s did not contain Packet-Type\n",
 326                                 radclient->packet_number, radclient->filename);
 327                         return -1;
 328                 }
 329
 330                 radclient->request->code = packet_code;
 331         }
 332         radclient->request->sockfd = -1;
 333
 334         return 0;
 335 }
 336
 337
 338 /*
 339  *      For request handline.
 340  */
 341 static int filename_cmp(const void *one, const void *two)
 342 {
 343         return strcmp((const char *) one, (const char *) two);
 344 }
 345
 346 static int filename_walk(void *context, void *data)
 347 {
 348         const char      *filename = data;
 349         radclient_t     *radclient;
 350
 351         context = context;      /* -Wunused */
 352
 353         /*
 354          *      Initialize the request we're about
 355          *      to send.
 356          */
 357         radclient = radclient_init(filename);
 358         if (!radclient) {
 359                 exit(1);
 360         }
 361
 362         if (!radclient_head) {
 363                 assert(radclient_tail == NULL);
 364                 radclient_head = radclient;
 365         } else {
 366                 assert(radclient_tail->next == NULL);
 367                 radclient_tail->next = radclient;
 368                 radclient->prev = radclient_tail;
 369         }
 370
 371         /*
 372          *      We may have had a list of "radclient" structures
 373          *      returned to us.
 374          */
 375         while (radclient->next) radclient = radclient->next;
 376         radclient_tail = radclient;
 377
 378         return 0;
 379 }
 380
 381
 382 /*
 383  *      Deallocate packet ID, etc.
 384  */
 385 static void deallocate_id(radclient_t *radclient)
 386 {
 387         if (!radclient || !radclient->request ||
 388             (radclient->request->id < 0)) {
 389                 return;
 390         }
 391
 392         /*
 393          *      One more unused RADIUS ID.
 394          */
 395         fr_packet_list_id_free(pl, radclient->request);
 396         radclient->request->id = -1;
 397
 398         /*
 399          *      If we've already sent a packet, free up the old one,
 400          *      and ensure that the next packet has a unique
 401          *      authentication vector.
 402          */
 403         if (radclient->request->data) {
 404                 free(radclient->request->data);
 405                 radclient->request->data = NULL;
 406         }
 407
 408         if (radclient->reply) rad_free(&radclient->reply);
 409 }
 410
 411
 412 static void print_hex(RADIUS_PACKET *packet)
 413 {
 414         int i;
 415
 416         if (!packet->data) return;
 417
 418         printf("  Code:\t\t%u\n", packet->data[0]);
 419         printf("  Id:\t\t%u\n", packet->data[1]);
 420         printf("  Length:\t%u\n", ((packet->data[2] << 8) |
 421                                    (packet->data[3])));
 422         printf("  Vector:\t");
 423         for (i = 4; i < 20; i++) {
 424                 printf("%02x", packet->data[i]);
 425         }
 426         printf("\n");
 427
 428         if (packet->data_len > 20) {
 429                 int total;
 430                 const uint8_t *ptr;
 431                 printf("  Data:");
 432
 433                 total = packet->data_len - 20;
 434                 ptr = packet->data + 20;
 435
 436                 while (total > 0) {
 437                         int attrlen, vsa = 0;
 438                         int mask = 16;
 439
 440                         printf("\t\t");
 441                         if (total < 2) { /* too short */
 442                                 printf("%02x\n", *ptr);
 443                                 break;
 444                         }
 445
 446                         if (ptr[1] > total) { /* too long */
 447                                 for (i = 0; i < total; i++) {
 448                                         printf("%02x ", ptr[i]);
 449                                 }
 450                                 break;
 451                         }
 452
 453                         if (ptr[0] == PW_VENDOR_SPECIFIC) vsa = 1;
 454
 455                         printf("%02x  %02x  ", ptr[0], ptr[1]);
 456                         attrlen = ptr[1] - 2;
 457                         ptr += 2;
 458                         total -= 2;
 459
 460                         if (vsa && (attrlen > 4)) {
 461                                 int vendor, vsa_tlen, vsa_llen;
 462                                 DICT_VENDOR *dv;
 463
 464                                 mask = 7;
 465                                 vendor = ((ptr[0] << 24) | (ptr[1] << 16) |
 466                                           (ptr[2] << 8) | ptr[3]);
 467                                 dv = dict_vendorbyvalue(vendor);
 468                                 vsa_tlen = vsa_llen = 1;
 469                                 if (dv) {
 470                                         vsa_tlen = dv->type;
 471                                         vsa_llen = dv->length;
 472                                 }
 473
 474                                 printf("%02x%02x%02x%02x  ",
 475                                        ptr[0], ptr[1], ptr[2], ptr[3]);
 476                                 ptr += 4;
 477                                 attrlen -= 4;
 478                                 total -= 4;
 479
 480                                 if (attrlen >= (vsa_tlen + vsa_llen)) {
 481                                         for (i = 0; i < vsa_tlen; i++) {
 482                                                 printf("%02x", ptr[i]);
 483                                         }
 484                                         printf("  ");
 485                                         ptr += vsa_tlen;
 486                                         attrlen -= vsa_tlen;
 487                                         total -= vsa_tlen;
 488
 489                                         for (i = 0; i < vsa_llen; i++) {
 490                                                 printf("%02x", ptr[i]);
 491                                         }
 492                                         printf("  ");
 493                                         ptr += vsa_llen;
 494                                         attrlen -= vsa_llen;
 495                                         total -= vsa_tlen;
 496                                 }
 497
 498                                 printf("\n\t\t\t\t");
 499                         }
 500
 501                         for (i = 0; i < attrlen; i++) {
 502                                 if ((i > 0) && ((i & mask) == 0x00)) {
 503                                         printf("\t\t\t");
 504                                         if (mask == 7) printf("\t");
 505                                 }
 506                                 printf("%02x ", ptr[i]);
 507                                 if ((i & mask) == mask) printf("\n");
 508                         }
 509
 510                         if ((attrlen & mask) != 0x00) printf("\n");
 511
 512                         ptr += attrlen;
 513                         total -= attrlen;
 514                 }
 515         }
 516         fflush(stdout);
 517 }
 518
 519 /*
 520  *      Send one packet.
 521  */
 522 static int send_one_packet(radclient_t *radclient)
 523 {
 524         assert(radclient->done == 0);
 525
 526         /*
 527          *      Remember when we have to wake up, to re-send the
 528          *      request, of we didn't receive a response.
 529          */
 530         if ((sleep_time == -1) ||
 531             (sleep_time > (int) timeout)) {
 532                 sleep_time = (int) timeout;
 533         }
 534
 535         /*
 536          *      Haven't sent the packet yet.  Initialize it.
 537          */
 538         if (radclient->request->id == -1) {
 539                 int i, rcode;
 540
 541                 assert(radclient->reply == NULL);
 542
 543                 /*
 544                  *      Didn't find a free packet ID, we're not done,
 545                  *      we don't sleep, and we stop trying to process
 546                  *      this packet.
 547                  */
 548         retry:
 549                 rcode = fr_packet_list_id_alloc(pl, radclient->request);
 550                 if (rcode < 0) {
 551                         int mysockfd;
 552
 553                         mysockfd = fr_socket(&client_ipaddr, 0);
 554                         if (!mysockfd) {
 555                                 fprintf(stderr, "radclient: Can't open new socket\n");
 556                                 exit(1);
 557                         }
 558                         if (!fr_packet_list_socket_add(pl, mysockfd)) {
 559                                 fprintf(stderr, "radclient: Can't add new socket\n");
 560                                 exit(1);
 561                         }
 562                         goto retry;
 563                 }
 564
 565                 if (rcode == 0) {
 566                         done = 0;
 567                         sleep_time = 0;
 568                         return 0;
 569                 }
 570
 571                 assert(radclient->request->id != -1);
 572                 assert(radclient->request->data == NULL);
 573
 574                 for (i = 0; i < 4; i++) {
 575                         ((uint32_t *) radclient->request->vector)[i] = fr_rand();
 576                 }
 577
 578                 /*
 579                  *      Update the password, so it can be encrypted with the
 580                  *      new authentication vector.
 581                  */
 582                 if (radclient->password[0] != '\0') {
 583                         VALUE_PAIR *vp;
 584
 585                         if ((vp = pairfind(radclient->request->vps, PW_USER_PASSWORD)) != NULL) {
 586                                 strlcpy(vp->vp_strvalue, radclient->password,
 587                                         sizeof(vp->vp_strvalue));
 588                                 vp->length = strlen(vp->vp_strvalue);
 589
 590                         } else if ((vp = pairfind(radclient->request->vps, PW_CHAP_PASSWORD)) != NULL) {
 591                           /*
 592                            *    FIXME: AND there's no CHAP-Challenge,
 593                            *           AND vp->length != 17
 594                            *           AND rad_chap_encode() != vp->vp_octets
 595                            */
 596                                 strlcpy(vp->vp_strvalue, radclient->password,
 597                                         sizeof(vp->vp_strvalue));
 598                                 vp->length = strlen(vp->vp_strvalue);
 599
 600                                 rad_chap_encode(radclient->request,
 601                                                 vp->vp_octets,
 602                                                 radclient->request->id, vp);
 603                                 vp->length = 17;
 604                         }
 605                 }
 606
 607                 radclient->timestamp = time(NULL);
 608                 radclient->tries = 1;
 609                 radclient->resend++;
 610
 611                 /*
 612                  *      Duplicate found.  Serious error!
 613                  */
 614                 if (!fr_packet_list_insert(pl, &radclient->request)) {
 615                         assert(0 == 1);
 616                 }
 617
 618         } else {                /* radclient->request->id >= 0 */
 619                 time_t now = time(NULL);
 620
 621                 /*
 622                  *      FIXME: Accounting packets are never retried!
 623                  *      The Acct-Delay-Time attribute is updated to
 624                  *      reflect the delay, and the packet is re-sent
 625                  *      from scratch!
 626                  */
 627
 628                 /*
 629                  *      Not time for a retry, do so.
 630                  */
 631                 if ((now - radclient->timestamp) < timeout) {
 632                         /*
 633                          *      When we walk over the tree sending
 634                          *      packets, we update the minimum time
 635                          *      required to sleep.
 636                          */
 637                         if ((sleep_time == -1) ||
 638                             (sleep_time > (now - radclient->timestamp))) {
 639                                 sleep_time = now - radclient->timestamp;
 640                         }
 641                         return 0;
 642                 }
 643
 644                 /*
 645                  *      We're not trying later, maybe the packet is done.
 646                  */
 647                 if (radclient->tries == retries) {
 648                         assert(radclient->request->id >= 0);
 649
 650                         /*
 651                          *      Delete the request from the tree of
 652                          *      outstanding requests.
 653                          */
 654                         fr_packet_list_yank(pl, radclient->request);
 655
 656                         fprintf(stderr, "radclient: no response from server for ID %d socket %d\n", radclient->request->id, radclient->request->sockfd);
 657                         deallocate_id(radclient);
 658
 659                         /*
 660                          *      Normally we mark it "done" when we've received
 661                          *      the response, but this is a special case.
 662                          */
 663                         if (radclient->resend == resend_count) {
 664                                 radclient->done = 1;
 665                         }
 666                         totallost++;
 667                         return -1;
 668                 }
 669
 670                 /*
 671                  *      We are trying later.
 672                  */
 673                 radclient->timestamp = now;
 674                 radclient->tries++;
 675         }
 676
 677
 678         /*
 679          *      Send the packet.
 680          */
 681         if (rad_send(radclient->request, NULL, secret) < 0) {
 682                 fprintf(stderr, "radclient: Failed to send packet for ID %d: %s\n",
 683                         radclient->request->id, fr_strerror());
 684         }
 685
 686         if (fr_debug_flag > 2) print_hex(radclient->request);
 687
 688         return 0;
 689 }
 690
 691 /*
 692  *      Receive one packet, maybe.
 693  */
 694 static int recv_one_packet(int wait_time)
 695 {
 696         fd_set          set;
 697         struct timeval  tv;
 698         radclient_t     *radclient;
 699         RADIUS_PACKET   *reply, **request_p;
 700         volatile int max_fd;
 701
 702         /* And wait for reply, timing out as necessary */
 703         FD_ZERO(&set);
 704
 705         max_fd = fr_packet_list_fd_set(pl, &set);
 706         if (max_fd < 0) exit(1); /* no sockets to listen on! */
 707
 708         if (wait_time <= 0) {
 709                 tv.tv_sec = 0;
 710         } else {
 711                 tv.tv_sec = wait_time;
 712         }
 713         tv.tv_usec = 0;
 714
 715         /*
 716          *      No packet was received.
 717          */
 718         if (select(max_fd, &set, NULL, NULL, &tv) <= 0) {
 719                 return 0;
 720         }
 721
 722         /*
 723          *      Look for the packet.
 724          */
 725         reply = fr_packet_list_recv(pl, &set);
 726         if (!reply) {
 727                 fprintf(stderr, "radclient: received bad packet: %s\n",
 728                         fr_strerror());
 729                 return -1;      /* bad packet */
 730         }
 731
 732         /*
 733          *      udpfromto issues.  We may have bound to "*",
 734          *      and we want to find the replies that are sent to
 735          *      (say) 127.0.0.1.
 736          */
 737         reply->dst_ipaddr = client_ipaddr;
 738
 739         if (fr_debug_flag > 2) print_hex(reply);
 740
 741         request_p = fr_packet_list_find_byreply(pl, reply);
 742         if (!request_p) {
 743                 fprintf(stderr, "radclient: received response to request we did not send. (id=%d socket %d)\n", reply->id, reply->sockfd);
 744                 rad_free(&reply);
 745                 return -1;      /* got reply to packet we didn't send */
 746         }
 747         radclient = fr_packet2myptr(radclient_t, request, request_p);
 748
 749         /*
 750          *      Fails the signature validation: not a real reply.
 751          *      FIXME: Silently drop it and listen for another packet.
 752          */
 753         if (rad_verify(reply, radclient->request, secret) < 0) {
 754                 fr_perror("rad_verify");
 755                 totallost++;
 756                 goto packet_done; /* shared secret is incorrect */
 757         }
 758
 759         fr_packet_list_yank(pl, radclient->request);
 760         if (print_filename) printf("%s:%d %d\n",
 761                                    radclient->filename,
 762                                    radclient->packet_number,
 763                                    reply->code);
 764         deallocate_id(radclient);
 765         radclient->reply = reply;
 766
 767         /*
 768          *      If this fails, we're out of memory.
 769          */
 770         if (rad_decode(reply, radclient->request, secret) != 0) {
 771                 fr_perror("rad_decode");
 772                 totallost++;
 773                 goto packet_done;
 774         }
 775
 776         /* libradius debug already prints out the value pairs for us */
 777         if (!fr_debug_flag && do_output) {
 778                 printf("Received response ID %d, code %d, length = %d\n",
 779                        reply->id, reply->code, reply->data_len);
 780                 vp_printlist(stdout, reply->vps);
 781         }
 782         if (reply->code != PW_AUTHENTICATION_REJECT) {
 783                 totalapp++;
 784         } else {
 785                 totaldeny++;
 786         }
 787
 788         if (radclient->resend == resend_count) {
 789                 radclient->done = 1;
 790         }
 791
 792  packet_done:
 793         rad_free(&radclient->reply);
 794
 795         return 0;
 796 }
 797
 798
 799 static int getport(const char *name)
 800 {
 801         struct  servent         *svp;
 802
 803         svp = getservbyname (name, "udp");
 804         if (!svp) {
 805                 return 0;
 806         }
 807
 808         return ntohs(svp->s_port);
 809 }
 810
 811 int main(int argc, char **argv)
 812 {
 813         char *p;
 814         int c;
 815         const char *radius_dir = RADDBDIR;
 816         char filesecret[256];
 817         FILE *fp;
 818         int do_summary = 0;
 819         int persec = 0;
 820         int parallel = 1;
 821         radclient_t     *this;
 822         int force_af = AF_UNSPEC;
 823
 824         fr_debug_flag = 0;
 825
 826         filename_tree = rbtree_create(filename_cmp, NULL, 0);
 827         if (!filename_tree) {
 828                 fprintf(stderr, "radclient: Out of memory\n");
 829                 exit(1);
 830         }
 831
 832         while ((c = getopt(argc, argv, "46c:d:f:Fhi:n:p:qr:sS:t:vx")) != EOF) switch(c) {
 833                 case '4':
 834                         force_af = AF_INET;
 835                         break;
 836                 case '6':
 837                         force_af = AF_INET6;
 838                         break;
 839                 case 'c':
 840                         if (!isdigit((int) *optarg))
 841                                 usage();
 842                         resend_count = atoi(optarg);
 843                         break;
 844                 case 'd':
 845                         radius_dir = optarg;
 846                         break;
 847                 case 'f':
 848                         rbtree_insert(filename_tree, optarg);
 849                         break;
 850                 case 'F':
 851                         print_filename = 1;
 852                         break;
 853                 case 'i':       /* currently broken */
 854                         if (!isdigit((int) *optarg))
 855                                 usage();
 856                         last_used_id = atoi(optarg);
 857                         if ((last_used_id < 0) || (last_used_id > 255)) {
 858                                 usage();
 859                         }
 860                         break;
 861
 862                 case 'n':
 863                         persec = atoi(optarg);
 864                         if (persec <= 0) usage();
 865                         break;
 866
 867                         /*
 868                          *      Note that sending MANY requests in
 869                          *      parallel can over-run the kernel
 870                          *      queues, and Linux will happily discard
 871                          *      packets.  So even if the server responds,
 872                          *      the client may not see the response.
 873                          */
 874                 case 'p':
 875                         parallel = atoi(optarg);
 876                         if (parallel <= 0) usage();
 877                         break;
 878
 879                 case 'q':
 880                         do_output = 0;
 881                         fr_log_fp = NULL; /* no output from you, either! */
 882                         break;
 883                 case 'r':
 884                         if (!isdigit((int) *optarg))
 885                                 usage();
 886                         retries = atoi(optarg);
 887                         if ((retries == 0) || (retries > 1000)) usage();
 888                         break;
 889                 case 's':
 890                         do_summary = 1;
 891                         break;
 892                case 'S':
 893                        fp = fopen(optarg, "r");
 894                        if (!fp) {
 895                                fprintf(stderr, "radclient: Error opening %s: %s\n",
 896                                        optarg, strerror(errno));
 897                                exit(1);
 898                        }
 899                        if (fgets(filesecret, sizeof(filesecret), fp) == NULL) {
 900                                fprintf(stderr, "radclient: Error reading %s: %s\n",
 901                                        optarg, strerror(errno));
 902                                exit(1);
 903                        }
 904                        fclose(fp);
 905
 906                        /* truncate newline */
 907                        p = filesecret + strlen(filesecret) - 1;
 908                        while ((p >= filesecret) &&
 909                               (*p < ' ')) {
 910                                *p = '\0';
 911                                --p;
 912                        }
 913
 914                        if (strlen(filesecret) < 2) {
 915                                fprintf(stderr, "radclient: Secret in %s is too short\n", optarg);
 916                                exit(1);
 917                        }
 918                        secret = filesecret;
 919                        break;
 920                 case 't':
 921                         if (!isdigit((int) *optarg))
 922                                 usage();
 923                         timeout = atof(optarg);
 924                         break;
 925                 case 'v':
 926                         printf("radclient: $Id$ built on " __DATE__ " at " __TIME__ "\n");
 927                         exit(0);
 928                         break;
 929                 case 'x':
 930                         fr_debug_flag++;
 931                         fr_log_fp = stdout;
 932                         break;
 933                 case 'h':
 934                 default:
 935                         usage();
 936                         break;
 937         }
 938         argc -= (optind - 1);
 939         argv += (optind - 1);
 940
 941         if ((argc < 3)  ||
 942             ((secret == NULL) && (argc < 4))) {
 943                 usage();
 944         }
 945
 946         if (dict_init(radius_dir, RADIUS_DICTIONARY) < 0) {
 947                 fr_perror("radclient");
 948                 return 1;
 949         }
 950
 951         /*
 952          *      Resolve hostname.
 953          */
 954         server_ipaddr.af = force_af;
 955         if (strcmp(argv[1], "-") != 0) {
 956                 const char *hostname = argv[1];
 957                 const char *portname = argv[1];
 958                 char buffer[256];
 959
 960                 if (*argv[1] == '[') { /* IPv6 URL encoded */
 961                         p = strchr(argv[1], ']');
 962                         if ((size_t) (p - argv[1]) >= sizeof(buffer)) {
 963                                 usage();
 964                         }
 965
 966                         memcpy(buffer, argv[1] + 1, p - argv[1] - 1);
 967                         buffer[p - argv[1] - 1] = '\0';
 968
 969                         hostname = buffer;
 970                         portname = p + 1;
 971
 972                 }
 973                 p = strchr(portname, ':');
 974                 if (p && (strchr(p + 1, ':') == NULL)) {
 975                         *p = '\0';
 976                         portname = p + 1;
 977                 } else {
 978                         portname = NULL;
 979                 }
 980
 981                 if (ip_hton(hostname, force_af, &server_ipaddr) < 0) {
 982                         fprintf(stderr, "radclient: Failed to find IP address for host %s: %s\n", hostname, strerror(errno));
 983                         exit(1);
 984                 }
 985
 986                 /*
 987                  *      Strip port from hostname if needed.
 988                  */
 989                 if (portname) server_port = atoi(portname);
 990         }
 991
 992         /*
 993          *      See what kind of request we want to send.
 994          */
 995         if (strcmp(argv[2], "auth") == 0) {
 996                 if (server_port == 0) server_port = getport("radius");
 997                 if (server_port == 0) server_port = PW_AUTH_UDP_PORT;
 998                 packet_code = PW_AUTHENTICATION_REQUEST;
 999
1000         } else if (strcmp(argv[2], "challenge") == 0) {
1001                 if (server_port == 0) server_port = getport("radius");
1002                 if (server_port == 0) server_port = PW_AUTH_UDP_PORT;
1003                 packet_code = PW_ACCESS_CHALLENGE;
1004
1005         } else if (strcmp(argv[2], "acct") == 0) {
1006                 if (server_port == 0) server_port = getport("radacct");
1007                 if (server_port == 0) server_port = PW_ACCT_UDP_PORT;
1008                 packet_code = PW_ACCOUNTING_REQUEST;
1009                 do_summary = 0;
1010
1011         } else if (strcmp(argv[2], "status") == 0) {
1012                 if (server_port == 0) server_port = getport("radius");
1013                 if (server_port == 0) server_port = PW_AUTH_UDP_PORT;
1014                 packet_code = PW_STATUS_SERVER;
1015
1016         } else if (strcmp(argv[2], "disconnect") == 0) {
1017                 if (server_port == 0) server_port = PW_POD_UDP_PORT;
1018                 packet_code = PW_DISCONNECT_REQUEST;
1019
1020         } else if (strcmp(argv[2], "coa") == 0) {
1021                 if (server_port == 0) server_port = PW_POD_UDP_PORT;
1022                 packet_code = PW_COA_REQUEST;
1023
1024         } else if (strcmp(argv[2], "auto") == 0) {
1025                 packet_code = -1;
1026
1027         } else if (isdigit((int) argv[2][0])) {
1028                 if (server_port == 0) server_port = getport("radius");
1029                 if (server_port == 0) server_port = PW_AUTH_UDP_PORT;
1030                 packet_code = atoi(argv[2]);
1031         } else {
1032                 usage();
1033         }
1034
1035         /*
1036          *      Add the secret.
1037          */
1038         if (argv[3]) secret = argv[3];
1039
1040         /*
1041          *      If no '-f' is specified, we're reading from stdin.
1042          */
1043         if (rbtree_num_elements(filename_tree) == 0) {
1044                 rbtree_insert(filename_tree, "-");
1045         }
1046
1047         /*
1048          *      Walk over the list of filenames, creating the requests.
1049          */
1050         if (rbtree_walk(filename_tree, InOrder, filename_walk, NULL) != 0) {
1051                 exit(1);
1052         }
1053
1054         /*
1055          *      No packets read.  Die.
1056          */
1057         if (!radclient_head) {
1058                 fprintf(stderr, "radclient: Nothing to send.\n");
1059                 exit(1);
1060         }
1061
1062         /*
1063          *      Bind to the first specified IP address and port.
1064          *      This means we ignore later ones.
1065          */
1066         if (radclient_head->request->src_ipaddr.af == AF_UNSPEC) {
1067                 memset(&client_ipaddr, 0, sizeof(client_ipaddr));
1068                 client_ipaddr.af = server_ipaddr.af;
1069                 client_port = 0;
1070         } else {
1071                 client_ipaddr = radclient_head->request->src_ipaddr;
1072                 client_port = radclient_head->request->src_port;
1073         }
1074         sockfd = fr_socket(&client_ipaddr, client_port);
1075         if (sockfd < 0) {
1076                 fprintf(stderr, "radclient: socket: %s\n", fr_strerror());
1077                 exit(1);
1078         }
1079
1080         pl = fr_packet_list_create(1);
1081         if (!pl) {
1082                 fprintf(stderr, "radclient: Out of memory\n");
1083                 exit(1);
1084         }
1085
1086         if (!fr_packet_list_socket_add(pl, sockfd)) {
1087                 fprintf(stderr, "radclient: Out of memory\n");
1088                 exit(1);
1089         }
1090
1091         /*
1092          *      Walk over the list of packets, sanity checking
1093          *      everything.
1094          */
1095         for (this = radclient_head; this != NULL; this = this->next) {
1096                 this->request->src_ipaddr = client_ipaddr;
1097                 this->request->src_port = client_port;
1098                 if (radclient_sane(this) != 0) {
1099                         exit(1);
1100                 }
1101         }
1102
1103         /*
1104          *      Walk over the packets to send, until
1105          *      we're all done.
1106          *
1107          *      FIXME: This currently busy-loops until it receives
1108          *      all of the packets.  It should really have some sort of
1109          *      send packet, get time to wait, select for time, etc.
1110          *      loop.
1111          */
1112         do {
1113                 int n = parallel;
1114                 radclient_t *next;
1115                 const char *filename = NULL;
1116
1117                 done = 1;
1118                 sleep_time = -1;
1119
1120                 /*
1121                  *      Walk over the packets, sending them.
1122                  */
1123
1124                 for (this = radclient_head; this != NULL; this = next) {
1125                         next = this->next;
1126
1127                         /*
1128                          *      If there's a packet to receive,
1129                          *      receive it, but don't wait for a
1130                          *      packet.
1131                          */
1132                         recv_one_packet(0);
1133
1134                         /*
1135                          *      This packet is done.  Delete it.
1136                          */
1137                         if (this->done) {
1138                                 radclient_free(this);
1139                                 continue;
1140                         }
1141
1142                         /*
1143                          *      Packets from multiple '-f' are sent
1144                          *      in parallel.
1145                          *
1146                          *      Packets from one file are sent in
1147                          *      series, unless '-p' is specified, in
1148                          *      which case N packets from each file
1149                          *      are sent in parallel.
1150                          */
1151                         if (this->filename != filename) {
1152                                 filename = this->filename;
1153                                 n = parallel;
1154                         }
1155
1156                         if (n > 0) {
1157                                 n--;
1158
1159                                 /*
1160                                  *      Send the current packet.
1161                                  */
1162                                 send_one_packet(this);
1163
1164                                 /*
1165                                  *      Wait a little before sending
1166                                  *      the next packet, if told to.
1167                                  */
1168                                 if (persec) {
1169                                         struct timeval tv;
1170
1171                                         /*
1172                                          *      Don't sleep elsewhere.
1173                                          */
1174                                         sleep_time = 0;
1175
1176                                         if (persec == 1) {
1177                                                 tv.tv_sec = 1;
1178                                                 tv.tv_usec = 0;
1179                                         } else {
1180                                                 tv.tv_sec = 0;
1181                                                 tv.tv_usec = 1000000/persec;
1182                                         }
1183
1184                                         /*
1185                                          *      Sleep for milliseconds,
1186                                          *      portably.
1187                                          *
1188                                          *      If we get an error or
1189                                          *      a signal, treat it like
1190                                          *      a normal timeout.
1191                                          */
1192                                         select(0, NULL, NULL, NULL, &tv);
1193                                 }
1194
1195                                 /*
1196                                  *      If we haven't sent this packet
1197                                  *      often enough, we're not done,
1198                                  *      and we shouldn't sleep.
1199                                  */
1200                                 if (this->resend < resend_count) {
1201                                         done = 0;
1202                                         sleep_time = 0;
1203                                 }
1204                         } else { /* haven't sent this packet, we're not done */
1205                                 assert(this->done == 0);
1206                                 assert(this->reply == NULL);
1207                                 done = 0;
1208                         }
1209                 }
1210
1211                 /*
1212                  *      Still have outstanding requests.
1213                  */
1214                 if (fr_packet_list_num_elements(pl) > 0) {
1215                         done = 0;
1216                 } else {
1217                         sleep_time = 0;
1218                 }
1219
1220                 /*
1221                  *      Nothing to do until we receive a request, so
1222                  *      sleep until then.  Once we receive one packet,
1223                  *      we go back, and walk through the whole list again,
1224                  *      sending more packets (if necessary), and updating
1225                  *      the sleep time.
1226                  */
1227                 if (!done && (sleep_time > 0)) {
1228                         recv_one_packet(sleep_time);
1229                 }
1230         } while (!done);
1231
1232         rbtree_free(filename_tree);
1233         fr_packet_list_free(pl);
1234         dict_free();
1235
1236         if (do_summary) {
1237                 printf("\n\t   Total approved auths:  %d\n", totalapp);
1238                 printf("\t     Total denied auths:  %d\n", totaldeny);
1239                 printf("\t       Total lost auths:  %d\n", totallost);
1240         }
1241
1242         return 0;
1243 }