blob: a5bc472afcf4924f469459d54e96d01fbc84041a [file] [log] [blame]
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* Originally developed by Aaron Bannert and Justin Erenkrantz, eBuilt.
*/
#include <apr_file_io.h>
#include <apr_strings.h>
#include <apr_errno.h>
#if APR_HAVE_STRING_H
#include <string.h> /* strncasecmp */
#endif
#if APR_HAVE_STDLIB_H
#include <stdlib.h> /* strtol */
#endif
#include "config.h"
#include "flood_profile.h"
#include "flood_config.h"
#include "flood_net.h"
#if FLOOD_HAS_OPENSSL
#include "flood_net_ssl.h"
#endif /* FLOOD_HAS_OPENSSL */
#include "flood_round_robin.h"
#include "flood_simple_reports.h"
#include "flood_easy_reports.h"
#include "flood_socket_generic.h"
#include "flood_socket_keepalive.h"
#include "flood_report_relative_times.h"
extern apr_file_t *local_stdout;
extern apr_file_t *local_stderr;
struct profile_event_handler_t {
const char *handler_name;
const char *impl_name;
void *handler;
};
typedef struct profile_event_handler_t profile_event_handler_t;
struct profile_group_handler_t {
const char *class;
const char *group_name;
const char **handlers;
};
typedef struct profile_group_handler_t profile_group_handler_t;
/**
* Generic implementation for profile_init.
*/
static apr_status_t generic_profile_init(profile_t **profile, config_t *config, const char * profile_name, apr_pool_t *pool)
{
return APR_ENOTIMPL;
}
/**
* Generic implementation for report_init.
*/
static apr_status_t generic_report_init(report_t **report, config_t *config, const char *profile_name, apr_pool_t *pool)
{
/* by default, don't generate a report */
*report = NULL;
return APR_SUCCESS;
}
/**
* Generic implementation for get_next_url.
*/
static apr_status_t generic_get_next_url(request_t **request, profile_t *profile)
{
return APR_ENOTIMPL;
}
/**
* Generic implementation for create_req.
*/
static apr_status_t generic_create_req(profile_t *profile, request_t *request)
{
return APR_ENOTIMPL;
}
/**
* Generic implementation for postprocess.
*/
static apr_status_t generic_postprocess(profile_t *p, request_t *req, response_t *resp)
{
return APR_SUCCESS;
}
/**
* Generic implementation for verify_resp.
*/
static apr_status_t generic_verify_resp(int *verified, profile_t *profile, request_t *req, response_t *resp)
{
return APR_ENOTIMPL;
}
/**
* Generic implementation for process_stats.
*/
static apr_status_t generic_process_stats(report_t *report, int verified, request_t *req, response_t *resp)
{
/* by default report nothing */
return APR_SUCCESS;
}
/**
* Generic implementation for loop_condition.
*/
static int generic_loop_condition(profile_t *p)
{
return 0; /* by default, don't loop */
}
/**
* Generic implementation for request_destroy.
*/
static apr_status_t generic_request_destroy(request_t *req)
{
return APR_SUCCESS;
}
/**
* Generic implementation for response_destroy.
*/
static apr_status_t generic_response_destroy(response_t *resp)
{
return APR_SUCCESS;
}
/**
* Generic implementation for report_stats.
*/
static apr_status_t generic_report_stats(report_t *report)
{
/* nothing to report, but not a failure */
return APR_SUCCESS;
}
/**
* Generic implementation for destroy_report.
*/
static apr_status_t generic_destroy_report(report_t *report)
{
return APR_SUCCESS;
}
/**
* Generic implementation for profile_destroy.
*/
static apr_status_t generic_profile_destroy(profile_t *p)
{
return APR_SUCCESS;
}
const char *profile_event_handler_names[] = {
"profile_init",
"report_init",
"get_next_url",
"socket_init",
"begin_conn",
"create_req",
"send_req",
"recv_resp",
"postprocess",
"verify_resp",
"process_stats",
"loop_condition",
"end_conn",
"request_destroy",
"response_destroy",
"socket_destroy",
"report_stats",
"destroy_report",
"profile_destroy",
NULL
};
profile_event_handler_t profile_event_handlers[] = {
{"profile_init", "generic_profile_init", &generic_profile_init},
{"report_init", "generic_report_init", &generic_report_init},
{"get_next_url", "generic_get_next_url", &generic_get_next_url},
{"socket_init", "generic_socket_init", &generic_socket_init},
{"begin_conn", "generic_begin_conn", &generic_begin_conn},
{"create_req", "generic_create_req", &generic_create_req},
{"send_req", "generic_send_req", &generic_send_req},
{"recv_resp", "generic_recv_resp", &generic_recv_resp},
{"postprocess", "generic_postprocess", &generic_postprocess},
{"verify_resp", "generic_verify_resp", &generic_verify_resp},
{"process_stats", "generic_process_stats", &generic_process_stats},
{"loop_condition", "generic_loop_condition", &generic_loop_condition},
{"end_conn", "generic_end_conn", &generic_end_conn},
{"request_destroy", "generic_request_destroy", &generic_request_destroy},
{"response_destroy", "generic_response_destroy", &generic_response_destroy},
{"socket_destroy", "generic_socket_destroy", &generic_socket_destroy},
{"report_stats", "generic_report_stats", &generic_report_stats},
{"destroy_report", "generic_destroy_report", &generic_destroy_report},
{"profile_destroy", "generic_profile_destroy", &generic_profile_destroy},
/* Alternative Implementations that are currently available: */
/* Always retrieve the full response */
{"recv_resp", "generic_fullresp_recv_resp", &generic_fullresp_recv_resp},
/* Keep-Alive support */
{"socket_init", "keepalive_socket_init", &keepalive_socket_init},
{"begin_conn", "keepalive_begin_conn", &keepalive_begin_conn},
{"send_req", "keepalive_send_req", &keepalive_send_req},
{"recv_resp", "keepalive_recv_resp", &keepalive_recv_resp},
{"end_conn", "keepalive_end_conn", &keepalive_end_conn},
{"socket_destroy", "keepalive_socket_destroy", &keepalive_socket_destroy},
/* Round Robin */
{"profile_init", "round_robin_profile_init", &round_robin_profile_init},
{"get_next_url", "round_robin_get_next_url", &round_robin_get_next_url},
{"create_req", "round_robin_create_req", &round_robin_create_req},
{"postprocess", "round_robin_postprocess", &round_robin_postprocess},
{"loop_condition", "round_robin_loop_condition", &round_robin_loop_condition},
{"profile_destroy", "round_robin_profile_destroy",&round_robin_profile_destroy},
/* Verification by OK/200 */
{"verify_resp", "verify_200", &verify_200},
{"verify_resp", "verify_status_code", &verify_status_code},
/* Simple Reports */
{"report_init", "simple_report_init", &simple_report_init},
{"process_stats", "simple_process_stats", &simple_process_stats},
{"report_stats", "simple_report_stats", &simple_report_stats},
{"destroy_report", "simple_destroy_report", &simple_destroy_report},
/* Easy Reports */
{"report_init", "easy_report_init", &easy_report_init},
{"process_stats", "easy_process_stats", &easy_process_stats},
{"report_stats", "easy_report_stats", &easy_report_stats},
{"destroy_report", "easy_destroy_report", &easy_destroy_report},
/* Relative Times Report */
{"report_init", "relative_times_report_init", &relative_times_report_init},
{"process_stats", "relative_times_process_stats", &relative_times_process_stats},
{"report_stats", "relative_times_report_stats", &relative_times_report_stats},
{"destroy_report", "relative_times_destroy_report",&relative_times_destroy_report},
{NULL} /* sentinel value */
};
const char * profile_group_handler_names[] = {
"report",
"socket",
"profiletype",
NULL
};
const char * report_easy_group[] = { "easy_report_init", "easy_process_stats", "easy_report_stats", "easy_destroy_report", NULL };
const char * report_simple_group[] = { "simple_report_init", "simple_process_stats", "simple_report_stats", "simple_destroy_report", NULL };
const char * socket_generic_group[] = { "generic_socket_init", "generic_begin_conn", "generic_send_req", "generic_recv_resp", "generic_end_conn", "generic_socket_destroy", NULL };
const char * socket_keepalive_group[] = { "keepalive_socket_init", "keepalive_begin_conn", "keepalive_send_req", "keepalive_recv_resp", "keepalive_end_conn", "keepalive_socket_destroy", NULL };
const char * profile_round_robin_group[] = { "round_robin_profile_init", "round_robin_get_next_url", "round_robin_create_req", "round_robin_postprocess", "round_robin_loop_condition", "round_robin_profile_destroy", NULL };
const char * report_relative_times_group[] = { "relative_times_report_init", "relative_times_process_stats", "relative_times_report_stats", "relative_times_destroy_report", NULL };
profile_group_handler_t profile_group_handlers[] = {
{"report", "easy", report_easy_group },
{"report", "simple", report_simple_group },
{"socket", "generic", socket_generic_group },
{"socket", "keepalive", socket_keepalive_group },
{"profiletype", "round_robin", profile_round_robin_group },
{"report", "relative_times", report_relative_times_group },
{NULL}
};
/**
* Assign the appropriate implementation to the profile_events_t handler
* for the given function name and overriden function name.
* Returns APR_SUCCESS if an appropriate handler was found and assigned, or
* returns APR_ENOTIMPL if no match was found.
*/
static apr_status_t assign_profile_event_handler(profile_events_t *events,
const char *handler_name,
const char *impl_name)
{
profile_event_handler_t *p;
for (p = &profile_event_handlers[0]; p && (*p).handler_name; p++) {
/* these are case insensitive (both key and value) for the sake of simplicity */
if (strncasecmp(impl_name, (*p).impl_name, FLOOD_STRLEN_MAX) == 0) {
if (strncasecmp(handler_name, (*p).handler_name, FLOOD_STRLEN_MAX) == 0) {
/* we got a match, assign it */
/* stupid cascading if, no big deal since it only happens at startup */
if (strncasecmp(handler_name, "profile_init", FLOOD_STRLEN_MAX) == 0) {
events->profile_init = (*p).handler;
} else if (strncasecmp(handler_name, "report_init", FLOOD_STRLEN_MAX) == 0){
events->report_init = (*p).handler;
} else if (strncasecmp(handler_name, "socket_init", FLOOD_STRLEN_MAX) == 0){
events->socket_init = (*p).handler;
} else if (strncasecmp(handler_name, "get_next_url", FLOOD_STRLEN_MAX) == 0){
events->get_next_url = (*p).handler;
} else if (strncasecmp(handler_name, "begin_conn", FLOOD_STRLEN_MAX) == 0) {
events->begin_conn = (*p).handler;
} else if (strncasecmp(handler_name, "create_req", FLOOD_STRLEN_MAX) == 0) {
events->create_req = (*p).handler;
} else if (strncasecmp(handler_name, "send_req", FLOOD_STRLEN_MAX) == 0) {
events->send_req = (*p).handler;
} else if (strncasecmp(handler_name, "recv_resp", FLOOD_STRLEN_MAX) == 0) {
events->recv_resp = (*p).handler;
} else if (strncasecmp(handler_name, "postprocess", FLOOD_STRLEN_MAX) == 0) {
events->postprocess = (*p).handler;
} else if (strncasecmp(handler_name, "verify_resp", FLOOD_STRLEN_MAX) == 0) {
events->verify_resp = (*p).handler;
} else if (strncasecmp(handler_name, "process_stats", FLOOD_STRLEN_MAX) == 0) {
events->process_stats = (*p).handler;
} else if (strncasecmp(handler_name, "loop_condition", FLOOD_STRLEN_MAX) == 0) {
events->loop_condition = (*p).handler;
} else if (strncasecmp(handler_name, "end_conn", FLOOD_STRLEN_MAX) == 0) {
events->end_conn = (*p).handler;
} else if (strncasecmp(handler_name, "request_destroy", FLOOD_STRLEN_MAX) == 0) {
events->request_destroy = (*p).handler;
} else if (strncasecmp(handler_name, "response_destroy", FLOOD_STRLEN_MAX) == 0) {
events->response_destroy = (*p).handler;
} else if (strncasecmp(handler_name, "socket_destroy", FLOOD_STRLEN_MAX) == 0) {
events->socket_destroy = (*p).handler;
} else if (strncasecmp(handler_name, "report_stats", FLOOD_STRLEN_MAX) == 0) {
events->report_stats = (*p).handler;
} else if (strncasecmp(handler_name, "destroy_report", FLOOD_STRLEN_MAX) == 0) {
events->destroy_report = (*p).handler;
} else if (strncasecmp(handler_name, "profile_destroy", FLOOD_STRLEN_MAX) == 0) {
events->profile_destroy = (*p).handler;
} else {
/* some internal error, our static structs don't match up */
return APR_EGENERAL;
}
return APR_SUCCESS;
} else {
/* invalid implementation for this handler */
apr_file_printf(local_stderr, "Invalid handler (%s) "
"specified.\n",
handler_name ? handler_name : "NULL");
return APR_ENOTIMPL; /* XXX: There's probably a better return val than this? */
}
}
}
apr_file_printf(local_stderr, "Invalid implementation (%s) for "
"this handler (%s)\n",
impl_name ? impl_name : "NULL",
handler_name ? handler_name : "NULL");
return APR_ENOTIMPL; /* no implementation found */
}
/**
* Assign all functions listed in the group to the profile_events_t handler
* Returns APR_SUCCESS if an appropriate handler was found and assigned, or
* returns APR_NOTFOUND if no match was found.
*/
static apr_status_t assign_profile_group_handler(profile_events_t *events,
const char *class_name,
const char *group_name)
{
profile_event_handler_t *p;
profile_group_handler_t *g;
const char **handlers;
/* Find our group. */
for (g = &profile_group_handlers[0]; g && g->class; g++)
{
if (!strncasecmp(class_name, g->class, FLOOD_STRLEN_MAX) &&
!strncasecmp(group_name, g->group_name, FLOOD_STRLEN_MAX))
break;
}
if (!g->class) {
apr_file_printf(local_stderr, "Invalid class '%s' or groupname '%s'.\n",
class_name, group_name);
return APR_EGENERAL;
}
/* For all of the handlers, set them. */
for (handlers = g->handlers; *handlers; handlers++)
{
for (p = profile_event_handlers; p && p->handler_name; p++) {
if (!strncasecmp(p->impl_name, *handlers, FLOOD_STRLEN_MAX))
assign_profile_event_handler(events, p->handler_name,
p->impl_name);
}
}
return APR_SUCCESS;
}
/**
* Construct a profile_event_handler_t struct, with the "generic"
* implementations in place by default.
*/
static apr_status_t create_profile_events(profile_events_t **events, apr_pool_t *pool)
{
apr_status_t stat;
profile_events_t *new_events;
if ((new_events = apr_pcalloc(pool, sizeof(profile_events_t))) == NULL)
return APR_ENOMEM;
if ((stat = assign_profile_event_handler(new_events,
"profile_init",
"generic_profile_init")) != APR_SUCCESS)
return stat;
if ((stat = assign_profile_event_handler(new_events,
"report_init",
"generic_report_init")) != APR_SUCCESS)
return stat;
if ((stat = assign_profile_event_handler(new_events,
"socket_init",
"generic_socket_init")) != APR_SUCCESS)
return stat;
if ((stat = assign_profile_event_handler(new_events,
"get_next_url",
"generic_get_next_url")) != APR_SUCCESS)
return stat;
if ((stat = assign_profile_event_handler(new_events,
"create_req",
"generic_create_req")) != APR_SUCCESS)
return stat;
if ((stat = assign_profile_event_handler(new_events,
"begin_conn",
"generic_begin_conn")) != APR_SUCCESS)
return stat;
if ((stat = assign_profile_event_handler(new_events,
"send_req",
"generic_send_req")) != APR_SUCCESS)
return stat;
if ((stat = assign_profile_event_handler(new_events,
"recv_resp",
"generic_recv_resp")) != APR_SUCCESS)
return stat;
if ((stat = assign_profile_event_handler(new_events,
"verify_resp",
"generic_verify_resp")) != APR_SUCCESS)
return stat;
if ((stat = assign_profile_event_handler(new_events,
"postprocess",
"generic_postprocess")) != APR_SUCCESS)
return stat;
if ((stat = assign_profile_event_handler(new_events,
"process_stats",
"generic_process_stats")) != APR_SUCCESS)
return stat;
if ((stat = assign_profile_event_handler(new_events,
"loop_condition",
"generic_loop_condition")) != APR_SUCCESS)
return stat;
if ((stat = assign_profile_event_handler(new_events,
"end_conn",
"generic_end_conn")) != APR_SUCCESS)
return stat;
if ((stat = assign_profile_event_handler(new_events,
"request_destroy",
"generic_request_destroy")) != APR_SUCCESS)
return stat;
if ((stat = assign_profile_event_handler(new_events,
"response_destroy",
"generic_response_destroy")) != APR_SUCCESS)
return stat;
if ((stat = assign_profile_event_handler(new_events,
"socket_destroy",
"generic_socket_destroy")) != APR_SUCCESS)
return stat;
if ((stat = assign_profile_event_handler(new_events,
"report_stats",
"generic_report_stats")) != APR_SUCCESS)
return stat;
if ((stat = assign_profile_event_handler(new_events,
"destroy_report",
"generic_destroy_report")) != APR_SUCCESS)
return stat;
if ((stat = assign_profile_event_handler(new_events,
"profile_destroy",
"generic_profile_destroy")) != APR_SUCCESS)
return stat;
*events = new_events;
return APR_SUCCESS;
}
/**
* Initializes the profile_events_t structure according to what we
* find in the given configuration. Dynamically allocated memory
* is pulled from the given pool.
*/
static apr_status_t initialize_events(profile_events_t **events, const char * profile_name, config_t *config, apr_pool_t *pool)
{
apr_status_t stat;
const char **p;
profile_events_t *new_events;
struct apr_xml_elem *root_elem, *profile_elem, *profile_event_elem;
char *xml_profile;
xml_profile = apr_pstrdup(pool, XML_PROFILE);
if ((stat = retrieve_root_xml_elem(&root_elem, config)) != APR_SUCCESS) {
return stat;
}
if ((stat = create_profile_events(&new_events, pool)) != APR_SUCCESS) {
return stat;
}
/* retrieve our profile xml element */
if ((stat = retrieve_xml_elem_with_childmatch(
&profile_elem, root_elem,
xml_profile, "name", profile_name)) != APR_SUCCESS)
return stat;
/* For each event in the profile_events_t struct, allow the config
* parameters to override an implementation.
*/
for (p = &profile_group_handler_names[0]; *p; p++) {
stat = retrieve_xml_elem_child(&profile_event_elem, profile_elem, *p);
/* We found a match */
if (stat == APR_SUCCESS)
{
stat = assign_profile_group_handler(new_events, *p,
profile_event_elem->first_cdata.first->text);
if (stat != APR_SUCCESS)
return stat;
}
}
/* For each event in the profile_events_t struct, allow the config
* parameters to override an implementation.
*/
for (p = &profile_event_handler_names[0]; *p; p++) {
if ((stat = retrieve_xml_elem_child(
&profile_event_elem,
profile_elem,
*p)) == APR_SUCCESS) {
/* search for the implementation in our tables and assign it */
if ((stat = assign_profile_event_handler(
new_events,
*p,
profile_event_elem->first_cdata.first->text)) != APR_SUCCESS) {
#ifdef PROFILE_DEBUG
apr_file_printf(local_stdout, "Profile '%s' failed to override '%s' with '%s'.\n",
profile_name, *p, profile_event_elem->first_cdata.first->text);
#endif /* PROFILE_DEBUG */
return stat;
} else {
#ifdef PROFILE_DEBUG
apr_file_printf(local_stdout, "Profile '%s' overrides '%s' with '%s'.\n",
profile_name, *p, profile_event_elem->first_cdata.first->text);
#endif /* PROFILE_DEBUG */
}
} else {
#ifdef PROFILE_DEBUG
apr_file_printf(local_stdout, "Profile '%s' uses default '%s'.\n",
profile_name, *p);
#endif /* PROFILE_DEBUG */
}
}
*events = new_events;
return APR_SUCCESS;
}
/**
* Essential guts of the main test loop -- a single run of a test profile:
*/
apr_status_t run_profile(apr_pool_t *pool, config_t *config, const char * profile_name)
{
profile_events_t *events;
profile_t *profile;
report_t *report;
request_t *req;
response_t *resp;
socket_t *socket;
flood_timer_t *timer;
apr_status_t stat;
int verified;
/* init to NULL for the sake of our error checking */
events = NULL;
profile = NULL;
req = NULL;
resp = NULL;
socket = NULL;
verified = FLOOD_INVALID;
/* assign the implementations (function pointers) */
if ((stat = initialize_events(&events, profile_name, config, pool)) != APR_SUCCESS) {
return stat;
}
if (events == NULL) {
apr_file_printf(local_stderr, "Error initializing test profile.\n");
return APR_EGENERAL; /* FIXME: What error code to return? */
}
/* initialize this profile */
if ((stat = events->profile_init(&profile, config, profile_name, pool)) != APR_SUCCESS)
return stat;
/* initialize this report */
if ((stat = events->report_init(&report, config, profile_name, pool)) != APR_SUCCESS)
return stat;
/* initialize the socket */
if ((stat = events->socket_init(&socket, pool)) != APR_SUCCESS)
return stat;
timer = apr_palloc(pool, sizeof(flood_timer_t));
do {
if ((stat = events->get_next_url(&req, profile)) != APR_SUCCESS)
return stat;
/* sample timer "begin" */
timer->begin = apr_time_now();
if ((stat = events->begin_conn(socket, req, pool)) != APR_SUCCESS) {
apr_file_printf(local_stderr, "open request failed (%s).\n",
req->uri);
return stat;
}
/* connect()ion was just made, sample it */
timer->connect = apr_time_now();
/* FIXME: I don't like doing this after we've opened the socket.
* But, I'm not sure how to do it otherwise.
*/
if ((stat = events->create_req(profile, req)) != APR_SUCCESS) {
apr_file_printf(local_stderr, "create request failed (%s).\n",
req->uri);
return stat;
}
/* If we wanted to keep track of our request generation overhead,
* we could take a timer sample here */
if ((stat = events->send_req(socket, req, pool)) != APR_SUCCESS) {
apr_file_printf(local_stderr, "send request failed (%s).\n",
req->uri);
return stat;
}
/* record the time at which we finished sending the entire request */
timer->write = apr_time_now();
if ((stat = events->recv_resp(&resp, socket, pool)) != APR_SUCCESS) {
apr_file_printf(local_stderr, "receive request failed (%s).\n",
req->uri);
return stat;
}
/* record the time at which we received the first chunk of response data */
timer->read = apr_time_now();
if ((stat = events->postprocess(profile, req, resp)) != APR_SUCCESS) {
apr_file_printf(local_stderr, "postprocessing failed (%s).\n",
req->uri);
return stat;
}
if ((stat = events->verify_resp(&verified, profile, req, resp)) != APR_SUCCESS) {
apr_file_printf(local_stderr,
"Error while verifying query (%s).\n", req->uri);
return stat;
}
if ((stat = events->end_conn(socket, req, resp)) != APR_SUCCESS) {
apr_file_printf(local_stderr,
"Unable to end the connection (%s).\n", req->uri);
return stat;
}
/* record the time at which we had finished reading the entire response.
* Note: this sample includes overhead from postprocessing and verification
* and is not a good representation of raw server response speed. */
timer->close = apr_time_now();
if ((stat = events->process_stats(report, verified, req, resp, timer)) != APR_SUCCESS) {
apr_file_printf(local_stderr,
"Unable to process statistics (%s).\n", req->uri);
return stat;
}
if ((stat = events->request_destroy(req)) != APR_SUCCESS) {
apr_file_printf(local_stderr, "Error cleaning up request.\n");
return stat;
}
if ((stat = events->response_destroy(resp)) != APR_SUCCESS) {
apr_file_printf(local_stderr, "Error cleaning up Response.\n");
return stat;
}
if ((stat = events->socket_destroy(socket)) != APR_SUCCESS) {
apr_file_printf(local_stderr, "Error cleaning up Socket.\n");
return stat;
}
} while (events->loop_condition(profile));
if ((stat = events->report_stats(report)) != APR_SUCCESS) {
apr_file_printf(local_stderr, "Unable to report statistics.\n");
return stat;
}
if (events->destroy_report(report) != APR_SUCCESS) {
apr_file_printf(local_stderr, "Error cleaning up report '%s'.\n", profile_name);
return APR_EGENERAL; /* FIXME: What error code to return? */
}
if (events->profile_destroy(profile) != APR_SUCCESS) {
apr_file_printf(local_stderr, "Error cleaning up profile '%s'.\n", profile_name);
return APR_EGENERAL; /* FIXME: What error code to return? */
}
return APR_SUCCESS;
}