*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*
* Copyright 2000 The FreeRADIUS server project
* Copyright 2000 Miquel van Smoorenburg <miquels@cistron.nl>
*/
static const char rcsid[] = "$Id$";
-#include "autoconf.h"
-#include "libradius.h"
+#include <freeradius-devel/autoconf.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <netdb.h>
-#include <sys/socket.h>
-
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#endif
#ifdef HAVE_SYS_SELECT_H
# include <sys/select.h>
#include <assert.h>
-#include "conf.h"
-#include "radpaths.h"
-#include "missing.h"
+#include <freeradius-devel/conf.h>
+#include <freeradius-devel/radpaths.h>
+#include <freeradius-devel/missing.h>
+#include <freeradius-devel/libradius.h>
static int retries = 10;
static float timeout = 3;
static int server_port = 0;
static int packet_code = 0;
-static uint32_t server_ipaddr = 0;
+static lrad_ipaddr_t server_ipaddr;
static int resend_count = 1;
static int done = 1;
+static lrad_ipaddr_t client_ipaddr;
+static int client_port = 0;
+
static int sockfd;
-static int radius_id[256];
-static int last_used_id = 0;
+static int last_used_id = -1;
static rbtree_t *filename_tree = NULL;
-static rbtree_t *request_tree = NULL;
+static lrad_packet_list_t *pl = NULL;
static int sleep_time = -1;
static radclient_t *radclient_tail = NULL;
-static void usage(void)
+static void NEVER_RETURNS usage(void)
{
fprintf(stderr, "Usage: radclient [options] server[:port] <command> [<secret>]\n");
-
- fprintf(stderr, " <command> One of auth, acct, status, or disconnect.\n");
+
+ fprintf(stderr, " <command> One of auth, acct, status, coa, or disconnect.\n");
fprintf(stderr, " -c count Send each packet 'count' times.\n");
fprintf(stderr, " -d raddb Set dictionary directory.\n");
fprintf(stderr, " -f file Read packets from file, not stdin.\n");
- fprintf(stderr, " -r retries If timeout, retry sending the packet 'retries' times.\n");
- fprintf(stderr, " -t timeout Wait 'timeout' seconds before retrying (may be a floating point number).\n");
fprintf(stderr, " -i id Set request id to 'id'. Values may be 0..255\n");
- fprintf(stderr, " -S file read secret from file, not command line.\n");
+ fprintf(stderr, " -n num Send N requests/s\n");
+ fprintf(stderr, " -p num Send 'num' packets from a file in parallel.\n");
fprintf(stderr, " -q Do not print anything out.\n");
+ fprintf(stderr, " -r retries If timeout, retry sending the packet 'retries' times.\n");
fprintf(stderr, " -s Print out summary information of auth results.\n");
+ fprintf(stderr, " -S file read secret from file, not command line.\n");
+ fprintf(stderr, " -t timeout Wait 'timeout' seconds before retrying (may be a floating point number).\n");
fprintf(stderr, " -v Show program version information.\n");
fprintf(stderr, " -x Debugging mode.\n");
+ fprintf(stderr, " -4 Use IPv4 address of server\n");
+ fprintf(stderr, " -6 Use IPv6 address of server.\n");
exit(1);
}
/*
- * Free a radclient struct
+ * Free a radclient struct, which may (or may not)
+ * already be in the list.
*/
static void radclient_free(radclient_t *radclient)
{
if (prev) {
assert(radclient_head != radclient);
prev->next = next;
- } else {
+ } else if (radclient_head) {
assert(radclient_head == radclient);
radclient_head = next;
}
-
+
if (next) {
assert(radclient_tail != radclient);
next->prev = prev;
- } else {
+ } else if (radclient_tail) {
assert(radclient_tail == radclient);
radclient_tail = prev;
}
int packet_number = 1;
start = NULL;
+ assert(filename != NULL);
/*
* Determine where to read the VP's from.
*/
- if (filename && (strcmp(filename, "-") != 0)) {
+ if (strcmp(filename, "-") != 0) {
fp = fopen(filename, "r");
if (!fp) {
fprintf(stderr, "radclient: Error opening %s: %s\n",
*/
radclient = malloc(sizeof(*radclient));
if (!radclient) {
- perror("radclient: ");
+ perror("radclient: X");
return NULL; /* memory leak "start" */
}
memset(radclient, 0, sizeof(*radclient));
-
+
radclient->request = rad_alloc(1);
if (!radclient->request) {
- librad_perror("radclient: ");
+ librad_perror("radclient: Y");
radclient_free(radclient);
return NULL; /* memory leak "start" */
}
-
+
radclient->filename = filename;
radclient->request->id = -1; /* allocate when sending */
radclient->packet_number = packet_number++;
-
+
/*
* Read the VP's.
*/
radclient->request->vps = readvp2(fp, &filedone, "radclient:");
if (!radclient->request->vps) {
radclient_free(radclient);
- return NULL; /* memory leak "start" */
+ return start; /* done: return the list */
}
-
+
/*
* Keep a copy of the the User-Password attribute.
*/
- if ((vp = pairfind(radclient->request->vps, PW_PASSWORD)) != NULL) {
- strNcpy(radclient->password, (char *)vp->strvalue, sizeof(vp->strvalue));
+ if ((vp = pairfind(radclient->request->vps, PW_USER_PASSWORD)) != NULL) {
+ strNcpy(radclient->password, vp->vp_strvalue,
+ sizeof(radclient->password));
/*
* Otherwise keep a copy of the CHAP-Password attribute.
*/
} else if ((vp = pairfind(radclient->request->vps, PW_CHAP_PASSWORD)) != NULL) {
- strNcpy(radclient->password, (char *)vp->strvalue, sizeof(vp->strvalue));
+ strNcpy(radclient->password, vp->vp_strvalue,
+ sizeof(radclient->password));
} else {
radclient->password[0] = '\0';
}
-
+
/*
* Fix up Digest-Attributes issues
*/
switch (vp->attribute) {
default:
break;
-
+
/*
* Allow it to set the packet type in
* the attributes read from the file.
case PW_PACKET_TYPE:
radclient->request->code = vp->lvalue;
break;
-
+
case PW_PACKET_DST_PORT:
radclient->request->dst_port = (vp->lvalue & 0xffff);
break;
-
+
+ case PW_PACKET_DST_IP_ADDRESS:
+ radclient->request->dst_ipaddr.af = AF_INET;
+ radclient->request->dst_ipaddr.ipaddr.ip4addr.s_addr = vp->lvalue;
+ break;
+
+ case PW_PACKET_DST_IPV6_ADDRESS:
+ radclient->request->dst_ipaddr.af = AF_INET6;
+ radclient->request->dst_ipaddr.ipaddr.ip6addr = vp->vp_ipv6addr;
+ break;
+
+ case PW_PACKET_SRC_PORT:
+ radclient->request->src_port = (vp->lvalue & 0xffff);
+ break;
+
+ case PW_PACKET_SRC_IP_ADDRESS:
+ radclient->request->src_ipaddr.af = AF_INET;
+ radclient->request->src_ipaddr.ipaddr.ip4addr.s_addr = vp->lvalue;
+ break;
+
+ case PW_PACKET_SRC_IPV6_ADDRESS:
+ radclient->request->src_ipaddr.af = AF_INET6;
+ radclient->request->src_ipaddr.ipaddr.ip6addr = vp->vp_ipv6addr;
+ break;
+
case PW_DIGEST_REALM:
case PW_DIGEST_NONCE:
case PW_DIGEST_METHOD:
case PW_DIGEST_NONCE_COUNT:
case PW_DIGEST_USER_NAME:
/* overlapping! */
- memmove(&vp->strvalue[2], &vp->strvalue[0], vp->length);
- vp->strvalue[0] = vp->attribute - PW_DIGEST_REALM + 1;
+ memmove(&vp->vp_octets[2], &vp->vp_octets[0],
+ vp->length);
+ vp->vp_octets[0] = vp->attribute - PW_DIGEST_REALM + 1;
vp->length += 2;
- vp->strvalue[1] = vp->length;
+ vp->vp_octets[1] = vp->length;
vp->attribute = PW_DIGEST_ATTRIBUTES;
break;
}
prev = radclient;
}
} while (!filedone); /* loop until the file is done. */
-
+
if (fp != stdin) fclose(fp);
-
+
/*
* And we're done.
*/
if (radclient->request->dst_port == 0) {
radclient->request->dst_port = server_port;
}
- radclient->request->dst_ipaddr = server_ipaddr;
-
+ if (radclient->request->dst_ipaddr.af == AF_UNSPEC) {
+ if (server_ipaddr.af == AF_UNSPEC) {
+ fprintf(stderr, "radclient: No server was given, but request %d in file %s did not contain Packet-Dst-IP-Address\n",
+ radclient->packet_number, radclient->filename);
+ return -1;
+ }
+ radclient->request->dst_ipaddr = server_ipaddr;
+ }
if (radclient->request->code == 0) {
if (packet_code == -1) {
fprintf(stderr, "radclient: Request was \"auto\", but request %d in file %s did not contain Packet-Type\n",
radclient->request->code = packet_code;
}
- radclient->request->sockfd = sockfd;
+ radclient->request->sockfd = -1;
return 0;
}
return strcmp((const char *) one, (const char *) two);
}
-static int filename_walk(void *data)
+static int filename_walk(void *context, void *data)
{
const char *filename = data;
radclient_t *radclient;
+ context = context; /* -Wunused */
+
/*
* Initialize the request we're about
* to send.
if (!radclient) {
exit(1);
}
-
+
if (!radclient_head) {
assert(radclient_tail == NULL);
radclient_head = radclient;
/*
- * Compare two RADIUS_PACKET data structures, based on a number
- * of criteria.
- */
-static int request_cmp(const void *one, const void *two)
-{
- const radclient_t *a = one;
- const radclient_t *b = two;
-
- /*
- * The following code looks unreasonable, but it's
- * the only way to make the comparisons work.
- */
- if (a->request->id < b->request->id) return -1;
- if (a->request->id > b->request->id) return +1;
-
- if (a->request->dst_ipaddr < b->request->dst_ipaddr) return -1;
- if (a->request->dst_ipaddr > b->request->dst_ipaddr) return +1;
-
- if (a->request->dst_port < b->request->dst_port) return -1;
- if (a->request->dst_port > b->request->dst_port) return +1;
-
- /*
- * Everything's equal. Say so.
- */
- return 0;
-}
-
-/*
- * "Free" a request.
+ * Deallocate packet ID, etc.
*/
-static void request_free(void *data)
+static void deallocate_id(radclient_t *radclient)
{
- radclient_t *radclient = (radclient_t *) data;
-
if (!radclient || !radclient->request ||
(radclient->request->id < 0)) {
return;
/*
* One more unused RADIUS ID.
*/
- radius_id[radclient->request->id] = 0;
+ lrad_packet_list_id_free(pl, radclient->request);
radclient->request->id = -1;
/*
}
+static void print_hex(RADIUS_PACKET *packet)
+{
+ int i;
+
+ if (!packet->data) return;
+
+ printf(" Code:\t\t%u\n", packet->data[0]);
+ printf(" Id:\t\t%u\n", packet->data[1]);
+ printf(" Length:\t%u\n", ((packet->data[2] << 8) |
+ (packet->data[3])));
+ printf(" Vector:\t");
+ for (i = 4; i < 20; i++) {
+ printf("%02x", packet->data[i]);
+ }
+ printf("\n");
+
+ if (packet->data_len > 20) {
+ int total;
+ const uint8_t *ptr;
+ printf(" Data:");
+
+ total = packet->data_len - 20;
+ ptr = packet->data + 20;
+
+ while (total > 0) {
+ int attrlen;
+
+ printf("\t\t");
+ if (total < 2) { /* too short */
+ printf("%02x\n", *ptr);
+ break;
+ }
+
+ if (ptr[1] > total) { /* too long */
+ for (i = 0; i < total; i++) {
+ printf("%02x ", ptr[i]);
+ }
+ break;
+ }
+
+ printf("%02x %02x ", ptr[0], ptr[1]);
+ attrlen = ptr[1] - 2;
+ ptr += 2;
+ total -= 2;
+
+ for (i = 0; i < attrlen; i++) {
+ if ((i > 0) && ((i & 0x0f) == 0x00))
+ printf("\t\t\t");
+ printf("%02x ", ptr[i]);
+ if ((i & 0x0f) == 0x0f) printf("\n");
+ }
+
+ if ((attrlen & 0x0f) != 0x00) printf("\n");
+
+ ptr += attrlen;
+ total -= attrlen;
+ }
+ }
+ fflush(stdout);
+}
+
/*
* Send one packet.
*/
static int send_one_packet(radclient_t *radclient)
{
- int i;
-
- /*
- * Sent this packet as many times as requested.
- * ignore it.
- */
- if (radclient->resend >= resend_count) {
- radclient->done = 1;
- return 0;
- }
+ assert(radclient->done == 0);
/*
* Remember when we have to wake up, to re-send the
* Haven't sent the packet yet. Initialize it.
*/
if (radclient->request->id == -1) {
- int found = 0;
+ int i, rcode;
assert(radclient->reply == NULL);
/*
- * Find a free packet Id
- */
- for (i = 0; i < 256; i++) {
- if (radius_id[(last_used_id + i) & 0xff] == 0) {
- last_used_id = (last_used_id + i) & 0xff;
- radius_id[last_used_id] = 1;
- radclient->request->id = last_used_id++;
- found = 1;
- break;
- }
- }
-
- /*
* Didn't find a free packet ID, we're not done,
* we don't sleep, and we stop trying to process
* this packet.
*/
- if (!found) {
+ retry:
+ rcode = lrad_packet_list_id_alloc(pl, radclient->request);
+ if (rcode < 0) {
+ int mysockfd;
+
+ mysockfd = lrad_socket(&client_ipaddr, 0);
+ if (!mysockfd) {
+ fprintf(stderr, "radclient: Can't open new socket\n");
+ exit(1);
+ }
+ if (!lrad_packet_list_socket_add(pl, mysockfd)) {
+ fprintf(stderr, "radclient: Can't add new socket\n");
+ exit(1);
+ }
+ goto retry;
+ }
+
+ if (rcode == 0) {
done = 0;
sleep_time = 0;
return 0;
assert(radclient->request->id != -1);
assert(radclient->request->data == NULL);
-
- librad_md5_calc(radclient->request->vector, radclient->request->vector,
- sizeof(radclient->request->vector));
-
+
+ for (i = 0; i < 4; i++) {
+ *((uint32_t *) radclient->request->vector) = lrad_rand();
+ }
+
/*
* Update the password, so it can be encrypted with the
* new authentication vector.
if (radclient->password[0] != '\0') {
VALUE_PAIR *vp;
- if ((vp = pairfind(radclient->request->vps, PW_PASSWORD)) != NULL) {
- strNcpy((char *)vp->strvalue, radclient->password, strlen(radclient->password) + 1);
- vp->length = strlen(radclient->password);
-
+ if ((vp = pairfind(radclient->request->vps, PW_USER_PASSWORD)) != NULL) {
+ strNcpy(vp->vp_strvalue, radclient->password,
+ sizeof(vp->vp_strvalue));
+ vp->length = strlen(vp->vp_strvalue);
+
} else if ((vp = pairfind(radclient->request->vps, PW_CHAP_PASSWORD)) != NULL) {
- strNcpy((char *)vp->strvalue, radclient->password, strlen(radclient->password) + 1);
- vp->length = strlen(radclient->password);
-
- rad_chap_encode(radclient->request, (char *) vp->strvalue, radclient->request->id, vp);
+ /*
+ * FIXME: AND there's no CHAP-Challenge,
+ * AND vp->length != 17
+ * AND rad_chap_encode() != vp->vp_octets
+ */
+ strNcpy(vp->vp_strvalue, radclient->password,
+ sizeof(vp->vp_strvalue));
+ vp->length = strlen(vp->vp_strvalue);
+
+ rad_chap_encode(radclient->request,
+ vp->vp_octets,
+ radclient->request->id, vp);
vp->length = 17;
}
}
/*
* Duplicate found. Serious error!
*/
- if (rbtree_insert(request_tree, radclient) == 0) {
+ if (!lrad_packet_list_insert(pl, &radclient->request)) {
assert(0 == 1);
}
-
- } else if (radclient->tries == retries) {
- rbnode_t *node;
- assert(radclient->request->id >= 0);
-
- /*
- * Delete the request from the tree of outstanding
- * requests.
- */
- node = rbtree_find(request_tree, radclient);
- assert(node != NULL);
-
- fprintf(stderr, "radclient: no response from server for ID %d\n", radclient->request->id);
- rbtree_delete(request_tree, node);
- totallost++;
- return -1;
-
- /*
- * FIXME: Do stuff for packet loss.
- */
+
} else { /* radclient->request->id >= 0 */
time_t now = time(NULL);
return 0;
}
+ /*
+ * We're not trying later, maybe the packet is done.
+ */
+ if (radclient->tries == retries) {
+ assert(radclient->request->id >= 0);
+
+ /*
+ * Delete the request from the tree of
+ * outstanding requests.
+ */
+ lrad_packet_list_yank(pl, radclient->request);
+
+ fprintf(stderr, "radclient: no response from server for ID %d socket %d\n", radclient->request->id, radclient->request->sockfd);
+ deallocate_id(radclient);
+
+ /*
+ * Normally we mark it "done" when we've received
+ * the response, but this is a special case.
+ */
+ if (radclient->resend == resend_count) {
+ radclient->done = 1;
+ }
+ totallost++;
+ return -1;
+ }
+
+ /*
+ * We are trying later.
+ */
radclient->timestamp = now;
radclient->tries++;
}
/*
* Send the packet.
*/
- rad_send(radclient->request, NULL, secret);
+ if (rad_send(radclient->request, NULL, secret) < 0) {
+ fprintf(stderr, "radclient: Failed to send packet for ID %d: %s\n",
+ radclient->request->id, librad_errstr);
+ }
+
+ if (librad_debug > 2) print_hex(radclient->request);
return 0;
}
{
fd_set set;
struct timeval tv;
- radclient_t myclient, *radclient;
- RADIUS_PACKET myrequest, *reply;
- rbnode_t *node;
+ radclient_t *radclient;
+ RADIUS_PACKET *reply, **request_p;
+ volatile int max_fd;
-
/* And wait for reply, timing out as necessary */
FD_ZERO(&set);
- FD_SET(sockfd, &set);
-
+
+ max_fd = lrad_packet_list_fd_set(pl, &set);
+ if (max_fd < 0) exit(1); /* no sockets to listen on! */
+
if (wait_time <= 0) {
tv.tv_sec = 0;
} else {
tv.tv_sec = wait_time;
}
tv.tv_usec = 0;
-
+
/*
* No packet was received.
*/
- if (select(sockfd + 1, &set, NULL, NULL, &tv) != 1) {
+ if (select(max_fd, &set, NULL, NULL, &tv) <= 0) {
return 0;
}
-
+
/*
* Look for the packet.
*/
- reply = rad_recv(sockfd);
+ reply = lrad_packet_list_recv(pl, &set);
if (!reply) {
- fprintf(stderr, "radclient: received bad packet\n");
+ fprintf(stderr, "radclient: received bad packet: %s\n",
+ librad_errstr);
return -1; /* bad packet */
}
- myclient.request = &myrequest;
- myrequest.id = reply->id;
- myrequest.dst_ipaddr = reply->src_ipaddr;
- myrequest.dst_port = reply->src_port;
+ if (librad_debug > 2) print_hex(reply);
- node = rbtree_find(request_tree, &myclient);
- if (!node) {
- fprintf(stderr, "radclient: received response to request we did not send.\n");
+ request_p = lrad_packet_list_find_byreply(pl, reply);
+ if (!request_p) {
+ fprintf(stderr, "radclient: received response to request we did not send. (id=%d socket %d)\n", reply->id, reply->sockfd);
+ rad_free(&reply);
return -1; /* got reply to packet we didn't send */
}
+ radclient = lrad_packet2myptr(radclient_t, request, request_p);
- radclient = rbtree_node2data(request_tree, node);
- assert(radclient != NULL);
- rbtree_delete(request_tree, node);
- assert(radclient->request->id == -1);
- assert(radclient->request->data == NULL);
+ /*
+ * Fails the signature validation: not a real reply.
+ * FIXME: Silently drop it and listen for another packet.
+ */
+ if (rad_verify(reply, radclient->request, secret) < 0) {
+ librad_perror("rad_verify");
+ totallost++;
+ goto packet_done; /* shared secret is incorrect */
+ }
- assert(radclient->reply == NULL);
+ lrad_packet_list_yank(pl, radclient->request);
+ deallocate_id(radclient);
radclient->reply = reply;
/*
- * FIXME: Do stuff to process the reply.
+ * If this fails, we're out of memory.
*/
if (rad_decode(reply, radclient->request, secret) != 0) {
librad_perror("rad_decode");
totallost++;
- return -1;
+ goto packet_done;
}
/* libradius debug already prints out the value pairs for us */
totaldeny++;
}
- if (radclient->reply) rad_free(&radclient->reply);
-
- return 0;
-}
-
-/*
- * Walk over the tree, sending packets.
- */
-static int radclient_send(radclient_t *radclient)
-{
- /*
- * Send the current packet.
- */
- send_one_packet(radclient);
+packet_done:
+ rad_free(&radclient->reply);
/*
- * Do rad_recv(), and look for the response in the tree,
- * but don't wait for a response.
+ * Once we've sent the packet as many times as requested,
+ * mark it done.
*/
- recv_one_packet(0);
-
- /*
- * Still elements to wa
- */
- if (radclient->resend < resend_count) {
- done = 0;
- sleep_time = 0;
+ if (radclient->resend == resend_count) {
+ assert(lrad_packet_list_find(pl, radclient->request) == NULL);
+ radclient->done = 1;
}
return 0;
}
+
static int getport(const char *name)
{
struct servent *svp;
char filesecret[256];
FILE *fp;
int do_summary = 0;
- int id;
+ int persec = 0;
+ int parallel = 1;
radclient_t *this;
+ int force_af = AF_UNSPEC;
- id = ((int)getpid() & 0xff);
librad_debug = 0;
filename_tree = rbtree_create(filename_cmp, NULL, 0);
exit(1);
}
- request_tree = rbtree_create(request_cmp, request_free, 0);
- if (!request_tree) {
- fprintf(stderr, "radclient: Out of memory\n");
- exit(1);
- }
-
- while ((c = getopt(argc, argv, "c:d:f:hi:qst:r:S:xv")) != EOF) switch(c) {
+ while ((c = getopt(argc, argv, "46c:d:f:hi:n:p:qr:sS:t:vx")) != EOF) switch(c) {
+ case '4':
+ force_af = AF_INET;
+ break;
+ case '6':
+ force_af = AF_INET6;
+ break;
case 'c':
- if (!isdigit((int) *optarg))
+ if (!isdigit((int) *optarg))
usage();
resend_count = atoi(optarg);
break;
case 'f':
rbtree_insert(filename_tree, optarg);
break;
+ case 'i': /* currently broken */
+ if (!isdigit((int) *optarg))
+ usage();
+ last_used_id = atoi(optarg);
+ if ((last_used_id < 0) || (last_used_id > 255)) {
+ usage();
+ }
+ break;
+
+ case 'n':
+ persec = atoi(optarg);
+ if (persec <= 0) usage();
+ break;
+
+ /*
+ * Note that sending MANY requests in
+ * parallel can over-run the kernel
+ * queues, and Linux will happily discard
+ * packets. So even if the server responds,
+ * the client may not see the response.
+ */
+ case 'p':
+ parallel = atoi(optarg);
+ if (parallel <= 0) usage();
+ break;
+
case 'q':
do_output = 0;
break;
- case 'x':
- librad_debug++;
- break;
case 'r':
- if (!isdigit((int) *optarg))
+ if (!isdigit((int) *optarg))
usage();
retries = atoi(optarg);
- break;
- case 'i':
- if (!isdigit((int) *optarg))
- usage();
- id = atoi(optarg);
- if ((id < 0) || (id > 255)) {
- usage();
- }
+ if ((retries == 0) || (retries > 1000)) usage();
break;
case 's':
do_summary = 1;
break;
- case 't':
- if (!isdigit((int) *optarg))
- usage();
- timeout = atof(optarg);
- break;
- case 'v':
- printf("radclient: $Id$ built on " __DATE__ " at " __TIME__ "\n");
- exit(0);
- break;
case 'S':
fp = fopen(optarg, "r");
if (!fp) {
}
secret = filesecret;
break;
+ case 't':
+ if (!isdigit((int) *optarg))
+ usage();
+ timeout = atof(optarg);
+ break;
+ case 'v':
+ printf("radclient: $Id$ built on " __DATE__ " at " __TIME__ "\n");
+ exit(0);
+ break;
+ case 'x':
+ librad_debug++;
+ break;
case 'h':
default:
usage();
}
/*
- * Strip port from hostname if needed.
+ * Resolve hostname.
*/
- if ((p = strchr(argv[1], ':')) != NULL) {
- *p++ = 0;
- server_port = atoi(p);
- }
+ server_ipaddr.af = force_af;
+ if (strcmp(argv[1], "-") != 0) {
+ const char *hostname = argv[1];
+ const char *portname = argv[1];
+ char buffer[256];
+
+ if (*argv[1] == '[') { /* IPv6 URL encoded */
+ p = strchr(argv[1], ']');
+ if ((p - argv[1]) >= sizeof(buffer)) {
+ usage();
+ }
+
+ memcpy(buffer, argv[1] + 1, p - argv[1] - 1);
+ buffer[p - argv[1] - 1] = '\0';
- /*
- * Grab the socket.
- */
- if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
- perror("radclient: socket: ");
- exit(1);
+ hostname = buffer;
+ portname = p + 1;
+
+ }
+ p = strchr(portname, ':');
+ if (p && (strchr(p + 1, ':') == NULL)) {
+ *p = '\0';
+ portname = p + 1;
+ } else {
+ portname = NULL;
+ }
+
+ if (ip_hton(hostname, force_af, &server_ipaddr) < 0) {
+ fprintf(stderr, "radclient: Failed to find IP address for host %s: %s\n", hostname, strerror(errno));
+ exit(1);
+ }
+
+ /*
+ * Strip port from hostname if needed.
+ */
+ if (portname) server_port = atoi(portname);
}
- memset(radius_id, 0, sizeof(radius_id));
/*
* See what kind of request we want to send.
if (server_port == 0) server_port = PW_AUTH_UDP_PORT;
packet_code = PW_AUTHENTICATION_REQUEST;
+ } else if (strcmp(argv[2], "challenge") == 0) {
+ if (server_port == 0) server_port = getport("radius");
+ if (server_port == 0) server_port = PW_AUTH_UDP_PORT;
+ packet_code = PW_ACCESS_CHALLENGE;
+
} else if (strcmp(argv[2], "acct") == 0) {
if (server_port == 0) server_port = getport("radacct");
if (server_port == 0) server_port = PW_ACCT_UDP_PORT;
if (server_port == 0) server_port = PW_POD_UDP_PORT;
packet_code = PW_DISCONNECT_REQUEST;
+ } else if (strcmp(argv[2], "coa") == 0) {
+ if (server_port == 0) server_port = PW_POD_UDP_PORT;
+ packet_code = PW_COA_REQUEST;
+
} else if (strcmp(argv[2], "auto") == 0) {
packet_code = -1;
}
/*
- * Resolve hostname.
+ * Add the secret.
*/
- server_ipaddr = ip_getaddr(argv[1]);
- if (server_ipaddr == INADDR_NONE) {
- fprintf(stderr, "radclient: Failed to find IP address for host %s\n", argv[1]);
- exit(1);
- }
+ if (argv[3]) secret = argv[3];
/*
- * Add the secret.
+ * If no '-f' is specified, we're reading from stdin.
*/
- if (argv[3]) secret = argv[3];
+ if (rbtree_num_elements(filename_tree) == 0) {
+ rbtree_insert(filename_tree, "-");
+ }
/*
* Walk over the list of filenames, creating the requests.
*/
- if (rbtree_walk(filename_tree, filename_walk, InOrder) != 0) {
+ if (rbtree_walk(filename_tree, InOrder, filename_walk, NULL) != 0) {
exit(1);
}
}
/*
+ * Bind to the first specified IP address and port.
+ * This means we ignore later ones.
+ */
+ if (radclient_head->request->src_ipaddr.af == AF_UNSPEC) {
+ memset(&client_ipaddr, 0, sizeof(client_ipaddr));
+ client_ipaddr.af = server_ipaddr.af;
+ client_port = 0;
+ } else {
+ client_ipaddr = radclient_head->request->src_ipaddr;
+ client_port = radclient_head->request->src_port;
+ }
+ sockfd = lrad_socket(&client_ipaddr, client_port);
+ if (sockfd < 0) {
+ fprintf(stderr, "radclient: socket: %s\n", librad_errstr);
+ exit(1);
+ }
+
+ pl = lrad_packet_list_create(1);
+ if (!pl) {
+ fprintf(stderr, "radclient: Out of memory\n");
+ exit(1);
+ }
+
+ if (!lrad_packet_list_socket_add(pl, sockfd)) {
+ fprintf(stderr, "radclient: Out of memory\n");
+ exit(1);
+ }
+
+ /*
* Walk over the list of packets, sanity checking
* everything.
*/
for (this = radclient_head; this != NULL; this = this->next) {
+ this->request->src_ipaddr = client_ipaddr;
+ this->request->src_port = client_port;
if (radclient_sane(this) != 0) {
exit(1);
}
}
- last_used_id = getpid() & 0xff;
-
/*
* Walk over the packets to send, until
* we're all done.
* loop.
*/
do {
+ int n = parallel;
radclient_t *next;
const char *filename = NULL;
/*
* Walk over the packets, sending them.
*/
-
+
for (this = radclient_head; this != NULL; this = next) {
next = this->next;
/*
+ * If there's a packet to receive,
+ * receive it, but don't wait for a
+ * packet.
+ */
+ recv_one_packet(0);
+
+ /*
+ * This packet is done. Delete it.
+ */
+ if (this->done) {
+ radclient_free(this);
+ continue;
+ }
+
+ /*
* Packets from multiple '-f' are sent
- * in parallel. Packets from one file
- * are sent in series.
+ * in parallel.
+ *
+ * Packets from one file are sent in
+ * series, unless '-p' is specified, in
+ * which case N packets from each file
+ * are sent in parallel.
*/
if (this->filename != filename) {
filename = this->filename;
- radclient_send(this);
- if (this->done) {
- radclient_free(this);
+ n = parallel;
+ }
+
+ if (n > 0) {
+ n--;
+
+ /*
+ * Send the current packet.
+ */
+ send_one_packet(this);
+
+ /*
+ * Wait a little before sending
+ * the next packet, if told to.
+ */
+ if (persec) {
+ struct timeval tv;
+
+ /*
+ * Don't sleep elsewhere.
+ */
+ sleep_time = 0;
+
+ if (persec == 1) {
+ tv.tv_sec = 1;
+ tv.tv_usec = 0;
+ } else {
+ tv.tv_sec = 0;
+ tv.tv_usec = 1000000/persec;
+ }
+
+ /*
+ * Sleep for milliseconds,
+ * portably.
+ *
+ * If we get an error or
+ * a signal, treat it like
+ * a normal timeout.
+ */
+ select(0, NULL, NULL, NULL, &tv);
+ }
+
+ /*
+ * If we haven't sent this packet
+ * often enough, we're not done,
+ * and we shouldn't sleep.
+ */
+ if (this->resend < resend_count) {
+ done = 0;
+ sleep_time = 0;
}
- } else {
+ } else { /* haven't sent this packet, we're not done */
assert(this->done == 0);
assert(this->reply == NULL);
done = 0;
/*
* Still have outstanding requests.
*/
- if (rbtree_num_elements(request_tree) > 0) {
+ if (lrad_packet_list_num_elements(pl) > 0) {
done = 0;
} else {
sleep_time = 0;
} while (!done);
rbtree_free(filename_tree);
- rbtree_free(request_tree);
+ lrad_packet_list_free(pl);
if (do_summary) {
printf("\n\t Total approved auths: %d\n", totalapp);
projects / freeradius.git / blobdiff