void request_stats_final(REQUEST *request) { if (request->master_state == REQUEST_COUNTED) return; if (!request->listener) return; if (!request->client) return; if ((request->listener->type != RAD_LISTEN_NONE) && #ifdef WITH_ACCOUNTING (request->listener->type != RAD_LISTEN_ACCT) && #endif #ifdef WITH_COA (request->listener->type != RAD_LISTEN_COA) && #endif (request->listener->type != RAD_LISTEN_AUTH)) return; /* don't count statistic requests */ if (request->packet->code == PW_CODE_STATUS_SERVER) return; #undef INC_AUTH #define INC_AUTH(_x) radius_auth_stats._x++;request->listener->stats._x++;request->client->auth._x++; #undef INC_ACCT #ifdef WITH_ACCOUNTING #define INC_ACCT(_x) radius_acct_stats._x++;request->listener->stats._x++;request->client->acct._x++ #else #define INC_ACCT(_x) #endif #undef INC_COA #ifdef WITH_COA #define INC_COA(_x) radius_coa_stats._x++;request->listener->stats._x++;request->client->coa._x++ #else #define INC_COA(_x) #endif #undef INC_DSC #ifdef WITH_DSC #define INC_DSC(_x) radius_dsc_stats._x++;request->listener->stats._x++;request->client->dsc._x++ #else #define INC_DSC(_x) #endif /* * Update the statistics. * * Note that we do NOT do this in a child thread. * Instead, we update the stats when a request is * deleted, because only the main server thread calls * this function, which makes it thread-safe. */ if (request->reply && (request->packet->code != PW_CODE_STATUS_SERVER)) switch (request->reply->code) { case PW_CODE_ACCESS_ACCEPT: INC_AUTH(total_access_accepts); auth_stats: INC_AUTH(total_responses); /* * FIXME: Do the time calculations once... */ stats_time(&radius_auth_stats, &request->packet->timestamp, &request->reply->timestamp); stats_time(&request->client->auth, &request->packet->timestamp, &request->reply->timestamp); stats_time(&request->listener->stats, &request->packet->timestamp, &request->reply->timestamp); break; case PW_CODE_ACCESS_REJECT: INC_AUTH(total_access_rejects); goto auth_stats; case PW_CODE_ACCESS_CHALLENGE: INC_AUTH(total_access_challenges); goto auth_stats; #ifdef WITH_ACCOUNTING case PW_CODE_ACCOUNTING_RESPONSE: INC_ACCT(total_responses); stats_time(&radius_acct_stats, &request->packet->timestamp, &request->reply->timestamp); stats_time(&request->client->acct, &request->packet->timestamp, &request->reply->timestamp); break; #endif #ifdef WITH_COA case PW_CODE_COA_ACK: INC_COA(total_access_accepts); coa_stats: INC_COA(total_responses); stats_time(&request->client->coa, &request->packet->timestamp, &request->reply->timestamp); break; case PW_CODE_COA_NAK: INC_COA(total_access_rejects); goto coa_stats; case PW_CODE_DISCONNECT_ACK: INC_DSC(total_access_accepts); dsc_stats: INC_DSC(total_responses); stats_time(&request->client->dsc, &request->packet->timestamp, &request->reply->timestamp); break; case PW_CODE_DISCONNECT_NAK: INC_DSC(total_access_rejects); goto dsc_stats; #endif /* * No response, it must have been a bad * authenticator. */ case 0: if (request->packet->code == PW_CODE_ACCESS_REQUEST) { if (request->reply->offset == -2) { INC_AUTH(total_bad_authenticators); } else { INC_AUTH(total_packets_dropped); } } else if (request->packet->code == PW_CODE_ACCOUNTING_REQUEST) { if (request->reply->offset == -2) { INC_ACCT(total_bad_authenticators); } else { INC_ACCT(total_packets_dropped); } } break; default: break; } #ifdef WITH_PROXY if (!request->proxy || !request->home_server) goto done; /* simplifies formatting */ switch (request->proxy->code) { case PW_CODE_ACCESS_REQUEST: proxy_auth_stats.total_requests += request->num_proxied_requests; request->home_server->stats.total_requests += request->num_proxied_requests; break; #ifdef WITH_ACCOUNTING case PW_CODE_ACCOUNTING_REQUEST: proxy_acct_stats.total_requests++; request->home_server->stats.total_requests += request->num_proxied_requests; break; #endif #ifdef WITH_COA case PW_CODE_COA_REQUEST: proxy_coa_stats.total_requests++; request->home_server->stats.total_requests += request->num_proxied_requests; break; case PW_CODE_DISCONNECT_REQUEST: proxy_dsc_stats.total_requests++; request->home_server->stats.total_requests += request->num_proxied_requests; break; #endif default: break; } if (!request->proxy_reply) goto done; /* simplifies formatting */ #undef INC #define INC(_x) proxy_auth_stats._x += request->num_proxied_responses; request->home_server->stats._x += request->num_proxied_responses; switch (request->proxy_reply->code) { case PW_CODE_ACCESS_ACCEPT: INC(total_access_accepts); proxy_stats: INC(total_responses); stats_time(&proxy_auth_stats, &request->proxy->timestamp, &request->proxy_reply->timestamp); stats_time(&request->home_server->stats, &request->proxy->timestamp, &request->proxy_reply->timestamp); break; case PW_CODE_ACCESS_REJECT: INC(total_access_rejects); goto proxy_stats; case PW_CODE_ACCESS_CHALLENGE: INC(total_access_challenges); goto proxy_stats; #ifdef WITH_ACCOUNTING case PW_CODE_ACCOUNTING_RESPONSE: proxy_acct_stats.total_responses++; request->home_server->stats.total_responses++; stats_time(&proxy_acct_stats, &request->proxy->timestamp, &request->proxy_reply->timestamp); stats_time(&request->home_server->stats, &request->proxy->timestamp, &request->proxy_reply->timestamp); break; #endif #ifdef WITH_COA case PW_CODE_COA_ACK: case PW_CODE_COA_NAK: proxy_coa_stats.total_responses++; request->home_server->stats.total_responses++; stats_time(&proxy_acct_stats, &request->proxy->timestamp, &request->proxy_reply->timestamp); stats_time(&request->home_server->stats, &request->proxy->timestamp, &request->proxy_reply->timestamp); break; case PW_CODE_DISCONNECT_ACK: case PW_CODE_DISCONNECT_NAK: proxy_coa_stats.total_responses++; request->home_server->stats.total_responses++; stats_time(&proxy_acct_stats, &request->proxy->timestamp, &request->proxy_reply->timestamp); stats_time(&request->home_server->stats, &request->proxy->timestamp, &request->proxy_reply->timestamp); break; #endif default: proxy_auth_stats.total_unknown_types++; request->home_server->stats.total_unknown_types++; break; } done: #endif /* WITH_PROXY */ request->master_state = REQUEST_COUNTED; }
void request_stats_final(REQUEST *request) { if (request->master_state == REQUEST_COUNTED) return; if ((request->listener->type != RAD_LISTEN_NONE) && (request->listener->type != RAD_LISTEN_AUTH) && (request->listener->type != RAD_LISTEN_ACCT)) return; #undef INC_AUTH #define INC_AUTH(_x) radius_auth_stats._x++;request->listener->stats._x++;if (request->client && request->client->auth) request->client->auth->_x++; #undef INC_ACCT #define INC_ACCT(_x) radius_acct_stats._x++;request->listener->stats._x++;if (request->client && request->client->acct) request->client->acct->_x++ /* * Update the statistics. * * Note that we do NOT do this in a child thread. * Instead, we update the stats when a request is * deleted, because only the main server thread calls * this function, which makes it thread-safe. */ switch (request->reply->code) { case PW_AUTHENTICATION_ACK: INC_AUTH(total_responses); INC_AUTH(total_access_accepts); break; case PW_AUTHENTICATION_REJECT: INC_AUTH(total_responses); INC_AUTH(total_access_rejects); break; case PW_ACCESS_CHALLENGE: INC_AUTH(total_responses); INC_AUTH(total_access_challenges); break; #ifdef WITH_ACCOUNTING case PW_ACCOUNTING_RESPONSE: INC_ACCT(total_responses); break; #endif /* * No response, it must have been a bad * authenticator. */ case 0: if (request->packet->code == PW_AUTHENTICATION_REQUEST) { if (request->reply->offset == -2) { INC_AUTH(total_bad_authenticators); } else { INC_AUTH(total_packets_dropped); } } else if (request->packet->code == PW_ACCOUNTING_REQUEST) { if (request->reply->offset == -2) { INC_ACCT(total_bad_authenticators); } else { INC_ACCT(total_packets_dropped); } } break; default: break; } #ifdef WITH_PROXY if (!request->proxy || !request->proxy_listener) goto done; /* simplifies formatting */ switch (request->proxy->code) { case PW_AUTHENTICATION_REQUEST: proxy_auth_stats.total_requests += request->num_proxied_requests; request->proxy_listener->stats.total_requests += request->num_proxied_requests; request->home_server->stats.total_requests += request->num_proxied_requests; break; #ifdef WITH_ACCOUNTING case PW_ACCOUNTING_REQUEST: proxy_acct_stats.total_requests++; request->proxy_listener->stats.total_requests += request->num_proxied_requests; request->home_server->stats.total_requests += request->num_proxied_requests; break; #endif default: break; } if (!request->proxy_reply) goto done; /* simplifies formatting */ #undef INC #define INC(_x) proxy_auth_stats._x += request->num_proxied_responses; request->proxy_listener->stats._x += request->num_proxied_responses; request->home_server->stats._x += request->num_proxied_responses; switch (request->proxy_reply->code) { case PW_AUTHENTICATION_ACK: INC(total_responses); INC(total_access_accepts); break; case PW_AUTHENTICATION_REJECT: INC(total_responses); INC(total_access_rejects); break; case PW_ACCESS_CHALLENGE: INC(total_responses); INC(total_access_challenges); break; #ifdef WITH_ACCOUNTING case PW_ACCOUNTING_RESPONSE: proxy_acct_stats.total_responses++; request->proxy_listener->stats.total_responses++; request->home_server->stats.total_responses++; break; #endif default: proxy_auth_stats.total_unknown_types++; request->proxy_listener->stats.total_unknown_types++; request->home_server->stats.total_unknown_types++; break; } done: #endif /* WITH_PROXY */ request->master_state = REQUEST_COUNTED; }