From: Arran Cudbard-Bell Date: Sun, 23 Feb 2020 23:13:15 +0000 (-0500) Subject: Use saner names for radius tracking tree and structures X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=850be5aa7158ff57bb772e283349272ba2fcb4d5;p=thirdparty%2Ffreeradius-server.git Use saner names for radius tracking tree and structures --- diff --git a/src/modules/rlm_radius/rlm_radius_udp.c b/src/modules/rlm_radius/rlm_radius_udp.c index ca3163e0b79..f2b93b5c638 100644 --- a/src/modules/rlm_radius/rlm_radius_udp.c +++ b/src/modules/rlm_radius/rlm_radius_udp.c @@ -101,7 +101,7 @@ typedef struct { uint8_t *buffer; //!< Receive buffer. size_t buflen; //!< Receive buffer length. - rlm_radius_id_t *id; //!< RADIUS ID tracking structure. + radius_track_t *tt; //!< RADIUS ID tracking structure. fr_time_t mrs_time; //!< Most recent sent time which had a reply. fr_time_t last_reply; //!< When we last received a reply. @@ -146,7 +146,7 @@ struct udp_request_s { size_t packet_len; //!< Length of the packet. udp_connection_t *c; //!< The outbound connection - rlm_radius_request_t *rr; //!< ID tracking, resend count, etc. + radius_track_entry_t *rr; //!< ID tracking, resend count, etc. fr_event_timer_t const *ev; //!< timer for retransmissions fr_retry_t retry; //!< retransmission timers }; @@ -241,7 +241,7 @@ static fr_connection_state_t conn_init(void **h_out, fr_connection_t *conn, void MEM(h->buffer = talloc_array(h, uint8_t, h->max_packet_size)); h->buflen = h->max_packet_size; - MEM(h->id = rr_track_create(h)); + MEM(h->tt = radius_track_alloc(h)); /* * Open the outgoing socket. @@ -400,7 +400,7 @@ static void status_check_alloc(fr_event_list_t *el, udp_handle_t *h) * demand. If the proxied packets use all of the * IDs, then we can't send a Status-Server check. */ - u->rr = rr_track_alloc(h->id, request, u->code, u); + u->rr = radius_track_entry_alloc(h->tt, request, u->code, u); if (!u->rr) { ERROR("%s - Failed allocating status_check ID for connection %s", h->module_name, h->name); @@ -876,7 +876,7 @@ static int encode(REQUEST *request, udp_request_t *u, udp_handle_t *h) * Remember the authentication vector, which now has the * packet signature. */ - (void) rr_track_update(h->id, u->rr, h->buffer + 4); + (void) radius_track_update(h->tt, u->rr, h->buffer + 4); RDEBUG("Sending %s ID %d length %ld over connection %s", fr_packet_codes[u->code], u->rr->id, packet_len, h->name); @@ -1111,8 +1111,8 @@ static void udp_request_clear(udp_request_t *u, udp_handle_t *h, fr_time_t now) { if (!now) now = fr_time(); - if (u->rr) (void) rr_track_delete(h->id, u->rr); - if (h->id->num_free == (h->status_u != NULL)) h->last_idle = now; + if (u->rr) (void) radius_track_delete(h->tt, u->rr); + if (h->tt->num_free == (h->status_u != NULL)) h->last_idle = now; u->rr = NULL; fr_pair_list_free(&u->extra); } @@ -1254,7 +1254,7 @@ static void request_mux(fr_event_list_t *el, * If it's an initial packet, allocate the ID. */ if (!u->rr) { - u->rr = rr_track_alloc(h->id, request, u->code, treq); + u->rr = radius_track_entry_alloc(h->tt, request, u->code, treq); if (!u->rr) { fail: u->c = NULL; @@ -1299,7 +1299,7 @@ static void request_mux(fr_event_list_t *el, * calling a complex API. */ if (inst->replicate) { - (void) rr_track_delete(h->id, u->rr); /* don't set last_idle, we're not checking for zombie */ + (void) radius_track_delete(h->tt, u->rr); /* don't set last_idle, we're not checking for zombie */ u->rr = NULL; r->rcode = RLM_MODULE_OK; fr_trunk_request_signal_complete(treq); @@ -1514,7 +1514,7 @@ static fr_trunk_request_t *read_packet(udp_handle_t *h, udp_connection_t *c) REQUEST *request; ssize_t data_len; size_t packet_len; - rlm_radius_request_t *rr; + radius_track_entry_t *rr; decode_fail_t reason; int code; VALUE_PAIR *reply, *vp; @@ -1560,7 +1560,7 @@ drain: * Note that we don't care about packet codes. All * packet codes share the same ID space. */ - rr = rr_track_find(h->id, h->buffer[1], NULL); + rr = radius_track_find(h->tt, h->buffer[1], NULL); if (!rr) { WARN("%s - Ignoring reply which arrived too late", h->module_name); return NULL; diff --git a/src/modules/rlm_radius/track.c b/src/modules/rlm_radius/track.c index 35ef49380ec..dcff504b6df 100644 --- a/src/modules/rlm_radius/track.c +++ b/src/modules/rlm_radius/track.c @@ -32,82 +32,80 @@ RCSID("$Id$") #include "track.h" #include "rlm_radius.h" -/** Create an rlm_radius_id_t +/** Create an radius_track_t * * @param ctx the talloc ctx * @return * - NULL on error - * - rlm_radius_id_t on success + * - radius_track_t on success */ -rlm_radius_id_t *rr_track_create(TALLOC_CTX *ctx) +radius_track_t *radius_track_alloc(TALLOC_CTX *ctx) { int i; - rlm_radius_id_t *id; + radius_track_t *tt; - id = talloc_zero(ctx, rlm_radius_id_t); - if (!id) return NULL; + MEM(tt = talloc_zero(ctx, radius_track_t)); - fr_dlist_init(&id->free_list, rlm_radius_request_t, entry); + fr_dlist_init(&tt->free_list, radius_track_entry_t, entry); for (i = 0; i < 256; i++) { - id->id[i].id = i; - fr_dlist_insert_tail(&id->free_list, &id->id[i]); - id->num_free++; + tt->id[i].id = i; + fr_dlist_insert_tail(&tt->free_list, &tt->id[i]); + tt->num_free++; } - id->next_id = fr_rand() & 0xff; + tt->next_id = fr_rand() & 0xff; - return id; + return tt; } -/** Compare two rlm_radius_request_t +/** Compare two radius_track_entry_t * */ -static int rr_cmp(void const *one, void const *two) +static int te_cmp(void const *one, void const *two) { - rlm_radius_request_t const *a = one; - rlm_radius_request_t const *b = two; + radius_track_entry_t const *a = one; + radius_track_entry_t const *b = two; return memcmp(a->vector, b->vector, sizeof(a->vector)); } /** Allocate a tracking entry. * - * @param[in] id The rlm_radius_id_t tracking table. + * @param[in] tt The radius_track_t tracking table. * @param[in] request The request which will send the proxied packet. * @param[in] code Of the outbound request. * @param rctx The context to associate with the request * @return * - NULL on error - * - rlm_radius_request_t on success + * - radius_track_entry_t on success */ -rlm_radius_request_t *rr_track_alloc(rlm_radius_id_t *id, REQUEST *request, int code, - void *rctx) +radius_track_entry_t *radius_track_entry_alloc(radius_track_t *tt, REQUEST *request, uint8_t code, void *rctx) { - rlm_radius_request_t *rr; + radius_track_entry_t *te; retry: - rr = fr_dlist_head(&id->free_list); - if (rr) { - rad_assert(id->num_free > 0); + te = fr_dlist_head(&tt->free_list); + if (te) { + rad_assert(tt->num_free > 0); - rad_assert(rr->request == NULL); + rad_assert(te->request == NULL); /* * Mark it as used, and remove it from the free list. */ - fr_dlist_remove(&id->free_list, rr); - id->num_free--; + fr_dlist_remove(&tt->free_list, te); + tt->num_free--; /* * We've transitioned from "use it", to "oops, * don't use it". Ensure that we only return IDs * which are in the static array. */ - if (!id->use_authenticator && - (rr != &id->id[rr->id])) { - talloc_free(rr); + if (!tt->use_authenticator && + (te != &tt->id[te->id])) { + talloc_free(te); goto retry; } @@ -118,61 +116,61 @@ retry: * There are no free entries, and we can't use the * Request Authenticator. Oh well... */ - if (!id->use_authenticator) return NULL; + if (!tt->use_authenticator) return NULL; /* * Get a new ID. It's value doesn't matter at this * point. */ - id->next_id++; - id->next_id &= 0xff; + tt->next_id++; + tt->next_id &= 0xff; /* * If needed, allocate a subtree. */ - if (!id->subtree[id->next_id]) { - id->subtree[id->next_id] = rbtree_talloc_create(id, rr_cmp, rlm_radius_request_t, + if (!tt->subtree[tt->next_id]) { + tt->subtree[tt->next_id] = rbtree_talloc_create(tt, te_cmp, radius_track_entry_t, NULL, RBTREE_FLAG_NONE); - if (!id->subtree[id->next_id]) return NULL; + if (!tt->subtree[tt->next_id]) return NULL; } /* * Allocate a new one, and insert it into the appropriate subtree. */ - rr = talloc_zero(id, rlm_radius_request_t); - rr->id = id->next_id; + te = talloc_zero(tt, radius_track_entry_t); + te->id = tt->next_id; done: - rr->request = request; - rr->rctx = rctx; + te->request = request; + te->rctx = rctx; - rr->code = code; + te->code = code; /* - * rr->id is already allocated + * te->id is already allocated */ - id->num_requests++; - return rr; + tt->num_requests++; + return te; } /** Update a tracking entry with the authentication vector * - * @param id The rlm_radius_id_t tracking table - * @param rr The rlm_radius_request_t, via rr_track_alloc() + * @param tt The radius_track_t tracking table + * @param te The radius_track_entry_t, via radius_track_entry_alloc() * @param vector The authentication vector for the packet we're sending * @return * - <0 on error * - 0 on success */ -int rr_track_update(rlm_radius_id_t *id, rlm_radius_request_t *rr, uint8_t *vector) +int radius_track_update(radius_track_t *tt, radius_track_entry_t *te, uint8_t *vector) { /* * The authentication vector may have changed. */ - if (id->subtree[rr->id]) (void) rbtree_deletebydata(id->subtree[rr->id], rr); + if (tt->subtree[te->id]) (void) rbtree_deletebydata(tt->subtree[te->id], te); - memcpy(rr->vector, vector, sizeof(rr->vector)); + memcpy(te->vector, vector, sizeof(te->vector)); /* * If we're not using the Request Authenticator, the @@ -180,8 +178,8 @@ int rr_track_update(rlm_radius_id_t *id, rlm_radius_request_t *rr, uint8_t *vect * * @todo - gracefully handle fallback if the server screws up. */ - if (!id->use_authenticator) { - rad_assert(rr == &id->id[rr->id]); + if (!tt->use_authenticator) { + rad_assert(te == &tt->id[te->id]); return 0; } @@ -192,9 +190,7 @@ int rr_track_update(rlm_radius_id_t *id, rlm_radius_request_t *rr, uint8_t *vect * array. That way if the server responds with * Original-Request-Authenticator, we can easily find it. */ - if (!rbtree_insert(id->subtree[rr->id], rr)) { - return -1; - } + if (!rbtree_insert(tt->subtree[te->id], te)) return -1; return 0; } @@ -202,30 +198,30 @@ int rr_track_update(rlm_radius_id_t *id, rlm_radius_request_t *rr, uint8_t *vect /** Delete a tracking entry * - * @param id The rlm_radius_id_t tracking table - * @param rr The rlm_radius_request_t, via rr_track_alloc() + * @param tt The radius_track_t tracking table + * @param te The radius_track_entry_t, via radius_track_entry_alloc() * @return * - <0 on error * - 0 on success */ -int rr_track_delete(rlm_radius_id_t *id, rlm_radius_request_t *rr) +int radius_track_delete(radius_track_t *tt, radius_track_entry_t *te) { - (void) talloc_get_type_abort(id, rlm_radius_id_t); + (void) talloc_get_type_abort(tt, radius_track_t); - rr->request = NULL; + te->request = NULL; - rad_assert(id->num_requests > 0); - id->num_requests--; + rad_assert(tt->num_requests > 0); + tt->num_requests--; /* * We're freeing a static ID, just go do that... */ - if (rr == &id->id[rr->id]) { + if (te == &tt->id[te->id]) { /* * This entry MAY be in a subtree. If so, delete * it. */ - if (id->subtree[rr->id]) (void) rbtree_deletebydata(id->subtree[rr->id], rr); + if (tt->subtree[te->id]) (void) rbtree_deletebydata(tt->subtree[te->id], te); goto done; } @@ -233,13 +229,13 @@ int rr_track_delete(rlm_radius_id_t *id, rlm_radius_request_t *rr) /* * At this point, it MUST be talloc'd. */ - (void) talloc_get_type_abort(rr, rlm_radius_request_t); + (void) talloc_get_type_abort(te, radius_track_entry_t); /* * Delete it from the tracking subtree. */ - rad_assert(id->subtree[rr->id] != NULL); - (void) rbtree_deletebydata(id->subtree[rr->id], rr); + rad_assert(tt->subtree[te->id] != NULL); + (void) rbtree_deletebydata(tt->subtree[te->id], te); /* * Try to free memory if the system gets idle. If the @@ -247,8 +243,8 @@ int rr_track_delete(rlm_radius_id_t *id, rlm_radius_request_t *rr) * free list. If the system becomes completely idle, we * will clear the free list. */ - if (id->num_free > id->num_requests) { - talloc_free(rr); + if (tt->num_free > tt->num_requests) { + talloc_free(te); return 0; } @@ -256,8 +252,8 @@ int rr_track_delete(rlm_radius_id_t *id, rlm_radius_request_t *rr) * Otherwise put it back on the free list. */ done: - fr_dlist_insert_tail(&id->free_list, rr); - id->num_free++; + fr_dlist_insert_tail(&tt->free_list, te); + tt->num_free++; return 0; } @@ -265,91 +261,86 @@ done: /** Find a tracking entry from a request authenticator * - * @param id The rlm_radius_id_t tracking table + * @param tt The radius_track_t tracking table * @param packet_id The ID from the RADIUS header * @param vector The Request Authenticator (may be NULL) * @return * - NULL on "not found" - * - rlm_radius_request_t on success + * - radius_track_entry_t on success */ -rlm_radius_request_t *rr_track_find(rlm_radius_id_t *id, int packet_id, uint8_t *vector) +radius_track_entry_t *radius_track_find(radius_track_t *tt, uint8_t packet_id, uint8_t *vector) { - rlm_radius_request_t my_rr, *rr; - - (void) talloc_get_type_abort(id, rlm_radius_id_t); + radius_track_entry_t my_te, *te; - /* - * Screw you guys, I'm going home! - */ - if (packet_id > 255) return NULL; + (void) talloc_get_type_abort(tt, radius_track_t); /* * Just use the static array. */ - if (!id->use_authenticator || !vector) { - rr = &id->id[packet_id]; + if (!tt->use_authenticator || !vector) { + te = &tt->id[packet_id]; /* * Not in use, die. */ - if (!rr->request) return NULL; + if (!te->request) return NULL; /* * Ignore the Request Authenticator, as the * caller doesn't have it. */ - return rr; + return te; } /* * The entry MAY be in the subtree! */ - memcpy(&my_rr.vector, vector, sizeof(my_rr.vector)); + memcpy(&my_te.vector, vector, sizeof(my_te.vector)); - rr = rbtree_finddata(id->subtree[packet_id], &my_rr); + te = rbtree_finddata(tt->subtree[packet_id], &my_te); /* * Not found, the packet MAY have been allocated in the * old-style method prior to negotiation of * Original-Request-Identifier. */ - if (!rr) { - rr = &id->id[packet_id]; + if (!te) { + te = &tt->id[packet_id]; /* * Not in use, die. */ - if (!rr->request) return NULL; + if (!te->request) return NULL; // @todo - add a "generation" count for packets, so we can skip this after all outstanding packets // are using the new method. Hmm... probably just a timer "last sent packet with old-style" - // and then compare it to rr->start + // and then compare it to te->start /* * We have the vector, so we need to check it. */ - if (memcmp(rr->vector, vector, sizeof(rr->vector)) != 0) { + if (memcmp(te->vector, vector, sizeof(te->vector)) != 0) { return NULL; } - return rr; + return te; } - (void) talloc_get_type_abort(rr, rlm_radius_request_t); - rad_assert(rr->request != NULL); + (void) talloc_get_type_abort(te, radius_track_entry_t); + rad_assert(te->request != NULL); - return rr; + return te; } /** Use Request Authenticator (or not) as an Identifier * - * @param id The rlm_radius_id_t tracking table + * @param tt The radius_track_t tracking table * @param flag Whether or not to use it. */ -void rr_track_use_authenticator(rlm_radius_id_t *id, bool flag) +void radius_track_use_authenticator(radius_track_t *tt, bool flag) { - (void) talloc_get_type_abort(id, rlm_radius_id_t); + (void) talloc_get_type_abort(tt, radius_track_t); - id->use_authenticator = flag; + tt->use_authenticator = flag; } diff --git a/src/modules/rlm_radius/track.h b/src/modules/rlm_radius/track.h index 6b62a91820a..da05d4b90a1 100644 --- a/src/modules/rlm_radius/track.h +++ b/src/modules/rlm_radius/track.h @@ -31,36 +31,40 @@ * */ typedef struct { - REQUEST *request; //!< as always... - void *rctx; + REQUEST *request; //!< as always... + void *rctx; //!< Result/resumption context. - int code; //!< packet code (sigh) - int id; //!< our ID + uint8_t code; //!< packet code (sigh) + uint8_t id; //!< our ID union { fr_dlist_t entry; //!< for free chain uint8_t vector[16]; //!< copy of the authentication vector }; -} rlm_radius_request_t; +} radius_track_entry_t; typedef struct { - int num_requests; //!< number of requests in the allocation - int num_free; //!< number of entries in the free list + int num_requests; //!< number of requests in the allocation + int num_free; //!< number of entries in the free list - fr_dlist_head_t free_list; //!< so we allocate by least recently used + fr_dlist_head_t free_list; //!< so we allocate by least recently used - bool use_authenticator; //!< whether to use the request authenticator as an ID - int next_id; //!< next ID to allocate + bool use_authenticator; //!< whether to use the request authenticator as an ID + int next_id; //!< next ID to allocate - rlm_radius_request_t id[256]; //!< which ID was used + radius_track_entry_t id[256]; //!< which ID was used - rbtree_t *subtree[256]; //!< for Original-Request-Authenticator -} rlm_radius_id_t; + rbtree_t *subtree[256]; //!< for Original-Request-Authenticator +} radius_track_t; -rlm_radius_id_t *rr_track_create(TALLOC_CTX *ctx); -rlm_radius_request_t *rr_track_alloc(rlm_radius_id_t *id, REQUEST *request, int code, - void *rctx) CC_HINT(nonnull); -int rr_track_update(rlm_radius_id_t *id, rlm_radius_request_t *rr, uint8_t *vector) CC_HINT(nonnull); -rlm_radius_request_t *rr_track_find(rlm_radius_id_t *id, int packet_id, uint8_t *vector) CC_HINT(nonnull(1)); -int rr_track_delete(rlm_radius_id_t *id, rlm_radius_request_t *rr) CC_HINT(nonnull); -void rr_track_use_authenticator(rlm_radius_id_t *id, bool flag) CC_HINT(nonnull); +radius_track_t *radius_track_alloc(TALLOC_CTX *ctx); + +radius_track_entry_t *radius_track_entry_alloc(radius_track_t *id, REQUEST *request, uint8_t code, void *rctx) CC_HINT(nonnull); + +int radius_track_update(radius_track_t *id, radius_track_entry_t *rr, uint8_t *vector) CC_HINT(nonnull); + +radius_track_entry_t *radius_track_find(radius_track_t *id, uint8_t packet_id, uint8_t *vector) CC_HINT(nonnull(1)); + +int radius_track_delete(radius_track_t *id, radius_track_entry_t *rr) CC_HINT(nonnull); + +void radius_track_use_authenticator(radius_track_t *id, bool flag) CC_HINT(nonnull);