static const char*
set_lockfile(cmd_parms *parms, void *mconfig, const char *arg)
{
akismet_config *sconf =
ap_get_module_config(parms->server->module_config, &akismet_module);
memset(global_lock_file, 0, strlen(global_lock_file) );
apr_cpystrn( global_lock_file, arg, strlen(arg)+1);
return NULL;
}
APR_DECLARE(const char *) apr_dso_error(apr_dso_handle_t *dso, char *buffer,
apr_size_t buflen)
{
if (dso->errormsg) {
apr_cpystrn(buffer, dso->errormsg, buflen);
return dso->errormsg;
}
return "No Error";
}
static void nx_win32_svc_install()
{
SC_HANDLE service_manager;
SC_HANDLE new_service = NULL;
HKEY regkey;
uint32_t regtype = 0;
char regvalbuf[1024];
uint32_t regvalbufsize = 1024;
char servicename[1024];
// Connect to service manager
service_manager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
if ( service_manager == NULL )
{
nx_win32_error("Cannot initialize access to the service manager");
}
//FIXME use nxlog.ctx.user to invoke service in CreateService
// default in case registry lookup would fail
apr_cpystrn(servicename,
"\"c:\\Program Files\\nxlog\\nxlog.exe\" -c \"c:\\Program Files\\nxlog\\nxlog.conf\"",
sizeof(servicename));
if ( RegOpenKey(HKEY_LOCAL_MACHINE, "SOFTWARE\\nxlog", ®key) == ERROR_SUCCESS )
{
if ( RegQueryValueEx(regkey, "installdir", 0, ®type,
(unsigned char *) regvalbuf, ®valbufsize) == ERROR_SUCCESS )
{
if ( regtype == REG_SZ )
{
apr_snprintf(servicename, sizeof(servicename), "\"%snxlog.exe\"", regvalbuf);
}
}
RegCloseKey(regkey);
}
// Install the new service
new_service = CreateService(service_manager, "nxlog", "nxlog",
SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS,
SERVICE_AUTO_START, SERVICE_ERROR_IGNORE,
servicename, NULL, NULL,
"eventlog\0", NULL, NULL);
if ( new_service == NULL )
{
nx_win32_error("Couldn't create service");
}
else
{
CloseServiceHandle(new_service);
log_info("Service successfully installed");
}
// Close the connection to service manager
CloseServiceHandle(service_manager);
}
static int prefork_pre_config(apr_pool_t *p, apr_pool_t *plog, apr_pool_t *ptemp)
{
static int restart_num = 0;
int no_detach, debug, foreground;
apr_status_t rv;
mpm_state = AP_MPMQ_STARTING;
debug = ap_exists_config_define("DEBUG");
if (debug) {
foreground = one_process = 1;
no_detach = 0;
}
else
{
no_detach = ap_exists_config_define("NO_DETACH");
one_process = ap_exists_config_define("ONE_PROCESS");
foreground = ap_exists_config_define("FOREGROUND");
}
/* sigh, want this only the second time around */
if (restart_num++ == 1) {
is_graceful = 0;
if (!one_process && !foreground) {
rv = apr_proc_detach(no_detach ? APR_PROC_DETACH_FOREGROUND
: APR_PROC_DETACH_DAEMONIZE);
if (rv != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_CRIT, rv, NULL,
"apr_proc_detach failed");
return HTTP_INTERNAL_SERVER_ERROR;
}
}
parent_pid = ap_my_pid = getpid();
}
unixd_pre_config(ptemp);
ap_listen_pre_config();
ap_daemons_to_start = DEFAULT_START_DAEMON;
ap_daemons_min_free = DEFAULT_MIN_FREE_DAEMON;
ap_daemons_max_free = DEFAULT_MAX_FREE_DAEMON;
ap_daemons_limit = server_limit;
ap_pid_fname = DEFAULT_PIDLOG;
ap_lock_fname = DEFAULT_LOCKFILE;
ap_max_requests_per_child = DEFAULT_MAX_REQUESTS_PER_CHILD;
ap_extended_status = 0;
#ifdef AP_MPM_WANT_SET_MAX_MEM_FREE
ap_max_mem_free = APR_ALLOCATOR_MAX_FREE_UNLIMITED;
#endif
apr_cpystrn(ap_coredump_dir, ap_server_root, sizeof(ap_coredump_dir));
return OK;
}
SWITCH_DECLARE(char *) switch_copy_string(char *dst, const char *src, switch_size_t dst_size)
{
if (!dst)
return NULL;
if (!src) {
*dst = '\0';
return dst;
}
return apr_cpystrn(dst, src, dst_size);
}
/* Set defaults for config directives implemented here. This is
* called from core's pre-config hook, so MPMs which need to override
* one of these should run their pre-config hook after that of core.
*/
void mpm_common_pre_config(apr_pool_t *pconf)
{
ap_pid_fname = DEFAULT_PIDLOG;
ap_max_requests_per_child = 0; /* unlimited */
apr_cpystrn(ap_coredump_dir, ap_server_root, sizeof(ap_coredump_dir));
ap_coredumpdir_configured = 0;
ap_graceful_shutdown_timeout = 0; /* unlimited */
ap_max_mem_free = ALLOCATOR_MAX_FREE_DEFAULT;
ap_thread_stacksize = 0; /* use system default */
}
static apr_status_t
lcn_segment_term_enum_next( lcn_term_enum_t *term_enum )
{
apr_status_t s = APR_SUCCESS;
if ( LCN_TRUE == term_enum->skip_first_next )
{
term_enum->skip_first_next = LCN_FALSE;
return APR_SUCCESS;
}
do
{
unsigned int i;
if ( term_enum->position++ >= ((apr_off_t)term_enum->size) - 1 )
{
s = LCN_ERR_ITERATOR_NO_NEXT;
break;
}
term_enum->prev->field = term_enum->term->field;
apr_cpystrn( term_enum->prev->text, term_enum->term->text, term_enum->buffer_size - 1 );
LCNCE( lcn_term_enum_read_term( term_enum ) );
/* read doc freq */
LCNCE( lcn_index_input_read_vint( term_enum->istream, &(term_enum->term_info->doc_freq) ));
/* read freq pointer */
LCNCE( lcn_index_input_read_vint( term_enum->istream, &i ) );
term_enum->term_info->freq_pointer += i;
/* read prox pointer */
LCNCE( lcn_index_input_read_vint( term_enum->istream, &i ) );
term_enum->term_info->prox_pointer += i;
if ( term_enum->term_info->doc_freq >= term_enum->skip_interval )
{
unsigned int skip_offset;
LCNCE( lcn_index_input_read_vint( term_enum->istream, &skip_offset ) );
term_enum->term_info->skip_offset = (apr_off_t) skip_offset;
}
/* read index ponter */
if ( term_enum->is_index )
{
LCNCE( lcn_index_input_read_vint( term_enum->istream, &i ) );
term_enum->index_pointer += i;
}
}
while(0);
return s;
}
/*****************************************************************************
* Session History
*/
apr_status_t
mod_but_shm_initialize_history(apr_pool_t *p, apr_pool_t *plog, apr_pool_t *ptemp, server_rec *s)
{
apr_status_t rv;
apr_pool_t *mypool;
apr_status_t sts;
apr_size_t size;
int i;
rv = apr_pool_create(&mypool, p);
if (rv != APR_SUCCESS) {
ERRLOG_SRV_INFO("(SHM HISTORY) Unable to create client pool for SHM history");
return rv;
}
size = (apr_size_t)MOD_BUT_SESSION_HISTORY_COUNT * sizeof(mod_but_cookie_history) + apr_rmm_overhead_get(MOD_BUT_SESSION_HISTORY_COUNT + 1);
ERRLOG_SRV_INFO("(SHM HISTORY) Size of the shared history memory allocation: %d kBytes", size/1024);
sts = apr_shm_create(&cs_shm_history, size, tmpnam(NULL), p);
if (sts != APR_SUCCESS) {
ERRLOG_SRV_INFO("(SHM HISTORY) Failed to create shared history memory");
return sts;
} else {
ERRLOG_SRV_INFO("(SHM HISTORY) Successfully created shared history memory");
}
sts = apr_rmm_init(&cs_rmm_history,NULL,apr_shm_baseaddr_get(cs_shm_history),size,p);
if (sts != APR_SUCCESS) {
ERRLOG_SRV_INFO("(SHM HISTORY) Failed to initialize the RMM segment");
return sts;
} else {
ERRLOG_SRV_INFO("(SHM HISTORY) Initialized RMM successfully");
}
ERRLOG_SRV_INFO("(SHM HISTORY) STARTING to malloc offsets in RMM");
off_history = apr_palloc(p, MOD_BUT_SESSION_HISTORY_COUNT * sizeof(apr_rmm_off_t));
for (i = 0; i < MOD_BUT_SESSION_HISTORY_COUNT; i++) {
//ERRLOG_SRV_INFO("Malloc cs_rmm_history %d", i);
off_history[i] = apr_rmm_malloc(cs_rmm_history, sizeof(mod_but_cookie_history));
}
/*
* Init of RMM with default values
*/
ERRLOG_SRV_INFO("(SHM HISTORY) STARTING to give every session the default values");
for (i = 0; i < MOD_BUT_SESSION_HISTORY_COUNT; i++) {
mod_but_cookie_history *c = apr_rmm_addr_get(cs_rmm_history, off_history[i]);
apr_cpystrn(c->session_value, "empty", sizeof(c->session_value));
}
ERRLOG_SRV_INFO("(SHM HISTORY) END to give every session the default values");
ERRLOG_SRV_INFO("(SHM HISTORY) Execution of mod_but_shm_initialize_history was successfully");
apr_pool_cleanup_register(mypool, NULL, shm_cleanup_history, apr_pool_cleanup_null);
return OK;
}
static void pm_norepeat_config(nx_module_t *module)
{
const nx_directive_t *curr;
nx_pm_norepeat_conf_t *modconf;
const char *start, *ptr, *end;
char *field = NULL;
apr_size_t len;
modconf = apr_pcalloc(module->pool, sizeof(nx_pm_norepeat_conf_t));
module->config = modconf;
curr = module->directives;
while ( curr != NULL )
{
if ( nx_module_common_keyword(curr->directive) == TRUE )
{
}
else if ( strcasecmp(curr->directive, "CheckFields") == 0 )
{
if ( modconf->fields != NULL )
{
nx_conf_error(curr, "CheckFields already defined");
}
ptr = curr->args;
for ( ; (ptr != NULL) && apr_isspace(*ptr); (ptr)++ );
if ( (curr->args == NULL) || (strlen(ptr) == 0) )
{
nx_conf_error(curr, "value missing for CheckFields");
}
end = ptr + strlen(ptr);
modconf->fields = apr_array_make(module->pool, 5, sizeof(const char *));
while ( *ptr != '\0' )
{
start = ptr;
for ( ; !((*ptr == '\0') || apr_isspace(*ptr) || (*ptr == ',')); ptr++ );
if ( ptr > start )
{
len = (apr_size_t) (ptr - start + 1);
field = apr_palloc(module->pool, len);
apr_cpystrn(field, start, len);
}
*((const char **) apr_array_push(modconf->fields)) = field;
for ( ; apr_isspace(*ptr) || (*ptr == ','); ptr++ );
}
}
else
{
nx_conf_error(curr, "invalid pm_norepeat keyword: %s", curr->directive);
}
curr = curr->next;
}
modconf->pid = (int) getpid();
}
static void ocmaint(int reason, void *data, int status)
{
switch (reason) {
case APR_OC_REASON_DEATH:
apr_cpystrn(reasonstr, "APR_OC_REASON_DEATH",
strlen("APR_OC_REASON_DEATH") + 1);
break;
case APR_OC_REASON_LOST:
apr_cpystrn(reasonstr, "APR_OC_REASON_LOST",
strlen("APR_OC_REASON_LOST") + 1);
break;
case APR_OC_REASON_UNWRITABLE:
apr_cpystrn(reasonstr, "APR_OC_REASON_UNWRITEABLE",
strlen("APR_OC_REASON_UNWRITEABLE") + 1);
break;
case APR_OC_REASON_RESTART:
apr_cpystrn(reasonstr, "APR_OC_REASON_RESTART",
strlen("APR_OC_REASON_RESTART") + 1);
break;
}
}
int output_status_json(output_t* output){
apr_table_add(output->headers,"Access-Control-Allow-Origin", "*");
apr_cpystrn((char*)output->content_type, "application/json", 255);
apr_brigade_puts(output->bucket_brigade, NULL,NULL, "{\n");
error_messages_print_json_bb(output->error_messages, output->pool,output->bucket_brigade);
apr_brigade_puts(output->bucket_brigade, NULL,NULL,"\n}\n");
return 0;
}
/*
* Renew session.
*
* Create a new session, copy details from old session to new
* session, and delete the old session.
*/
apr_status_t
renew_mod_but_session(request_rec *r, int shmoffold, int *shmoffnew)
{
apr_status_t rc;
apr_rmm_t *cs_rmm = find_cs_rmm();
apr_rmm_off_t *off = find_cs_rmm_off();
mod_but_server_t *config;
mod_but_cookie *c_old;
mod_but_cookie *c_new;
ERRLOG_INFO("Renewing sesssion");
config = ap_get_module_config(r->server->module_config, &but_module);
c_old = apr_rmm_addr_get(cs_rmm, off[shmoffold]);
rc = create_new_mod_but_session(r, r->headers_out, shmoffnew);
if (rc != STATUS_OK) {
ERRLOG_CRIT("Failed to create new session");
return rc;
}
c_new = apr_rmm_addr_get(cs_rmm, off[*shmoffnew]);
c_new->session_create_time = c_old->session_create_time;
c_new->session_last_access_time = c_old->session_last_access_time;
c_new->link_to_cookiestore = c_old->link_to_cookiestore;
c_new->logon_state = c_old->logon_state;
c_new->logon_flag = c_old->logon_flag;
c_new->auth_strength = c_old->auth_strength;
apr_cpystrn(c_new->orig_url_before_logon, c_old->orig_url_before_logon, sizeof(c_new->orig_url_before_logon));
apr_cpystrn(c_new->service_list, c_old->service_list, sizeof(c_new->service_list));
c_old->link_to_cookiestore = -1;
rc = mod_but_delete_session(shmoffold, r);
if (rc != STATUS_OK) {
ERRLOG_CRIT("Failed to delete old session");
return rc;
}
return STATUS_OK;
}
static apr_status_t
lcn_term_enum_grow_buffer( lcn_term_enum_t *term_enum, unsigned int len )
{
apr_status_t s = APR_SUCCESS;
do
{
if ( term_enum->buffer_size < len )
{
char *term_text;
char *prev_text;
apr_pool_t *save_pool = term_enum->save_pool;
LCNPV( term_text = (char*) apr_pcalloc( save_pool, len * sizeof(char) ),
APR_ENOMEM );
LCNPV( prev_text = (char*) apr_pcalloc( save_pool, len * sizeof(char) ),
APR_ENOMEM );
apr_cpystrn( term_text, term_enum->term_text, term_enum->buffer_size );
apr_cpystrn( prev_text, term_enum->prev_text, term_enum->buffer_size );
term_enum->save_pool = term_enum->buffer_pool;
term_enum->buffer_pool = save_pool;
apr_pool_clear( term_enum->save_pool );
term_enum->term_text = term_text;
term_enum->prev_text = prev_text;
term_enum->term->text = term_text;
term_enum->prev->text = prev_text;
term_enum->buffer_size = len;
}
}
while(0);
return s;
}
static void string_cpystrn(abts_case *tc, void *data)
{
char buf[6], *ret;
buf[5] = 'Z';
ret = apr_cpystrn(buf, "123456", 5);
ABTS_STR_EQUAL(tc, "1234", buf);
ABTS_PTR_EQUAL(tc, buf + 4, ret);
ABTS_TRUE(tc, *ret == '\0');
ABTS_TRUE(tc, ret[1] == 'Z');
}
static const char *
dav_rainx_cmd_gridconfig_namespace(cmd_parms *cmd, void *config, const char *arg1)
{
dav_rainx_server_conf *conf;
(void) config;
DAV_XDEBUG_POOL(cmd->pool, 0, "%s()", __FUNCTION__);
conf = ap_get_module_config(cmd->server->module_config, &dav_rainx_module);
memset(conf->ns_name, 0x00, sizeof(conf->ns_name));
apr_cpystrn(conf->ns_name, arg1, sizeof(conf->ns_name));
DAV_DEBUG_POOL(cmd->pool, 0, "NS=[%s]", conf->ns_name);
/* Prepare COMPRESSION / ACL CONF when we get ns name */
namespace_info_t* ns_info;
GError *local_error = NULL;
ns_info = get_namespace_info(conf->ns_name, &local_error);
if (!ns_info) {
DAV_DEBUG_POOL(cmd->temp_pool, 0, "Failed to get namespace info from ns [%s]", conf->ns_name);
return apr_pstrcat(cmd->temp_pool, "Failed to get namespace info from ns: ",
conf->ns_name, " ", local_error->message, NULL);
}
if (!conf->rainx_conf_lock) {
apr_thread_mutex_create(&(conf->rainx_conf_lock),
APR_THREAD_MUTEX_DEFAULT, conf->pool);
}
apr_thread_mutex_lock(conf->rainx_conf_lock);
conf->rainx_conf = apr_palloc(cmd->pool, sizeof(rawx_conf_t));
char * stgpol = NULL;
stgpol = namespace_storage_policy(ns_info, ns_info->name);
if(NULL != stgpol) {
conf->rainx_conf->sp = storage_policy_init(ns_info, stgpol);
} else {
conf->rainx_conf->sp = NULL;
}
conf->rainx_conf->ni = ns_info;
conf->rainx_conf->acl = _get_acl(cmd->pool, ns_info);
conf->rainx_conf->last_update = time(0);
apr_thread_mutex_unlock(conf->rainx_conf_lock);
if(local_error)
g_clear_error(&local_error);
return NULL;
}
APU_DECLARE(char *) apr_dbm_geterror(apr_dbm_t *dbm, int *errcode,
char *errbuf, apr_size_t errbufsize)
{
if (errcode != NULL)
*errcode = dbm->errcode;
/* assert: errbufsize > 0 */
if (dbm->errmsg == NULL)
*errbuf = '\0';
else
(void) apr_cpystrn(errbuf, dbm->errmsg, errbufsize);
return errbuf;
}
char *
svn_strerror(apr_status_t statcode, char *buf, apr_size_t bufsize)
{
const err_defn *defn;
for (defn = error_table; defn->errdesc != NULL; ++defn)
if (defn->errcode == (svn_errno_t)statcode)
{
apr_cpystrn(buf, _(defn->errdesc), bufsize);
return buf;
}
return apr_strerror(statcode, buf, bufsize);
}
void procmgr_init_spawn_cmd(fcgid_command * command, request_rec * r,
fcgid_cmd_conf *cmd_conf)
{
ap_unix_identity_t *ugid;
fcgid_server_conf *sconf =
ap_get_module_config(r->server->module_config, &fcgid_module);
/* suEXEC check */
if ((ugid = ap_run_get_suexec_identity(r))) {
command->uid = ugid->uid;
command->gid = ugid->gid;
command->userdir = ugid->userdir;
} else {
command->uid = (uid_t) - 1;
command->gid = (gid_t) - 1;
command->userdir = 0;
}
/* no truncation should ever occur */
AP_DEBUG_ASSERT(sizeof command->cgipath > strlen(cmd_conf->cgipath));
apr_cpystrn(command->cgipath, cmd_conf->cgipath, sizeof command->cgipath);
AP_DEBUG_ASSERT(sizeof command->cmdline > strlen(cmd_conf->cmdline));
apr_cpystrn(command->cmdline, cmd_conf->cmdline, sizeof command->cmdline);
command->deviceid = cmd_conf->deviceid;
command->inode = cmd_conf->inode;
command->vhost_id = sconf->vhost_id;
if (r->server->server_hostname) {
apr_cpystrn(command->server_hostname, r->server->server_hostname,
sizeof command->server_hostname);
}
else {
command->server_hostname[0] = '\0';
}
get_cmd_options(r, command->cgipath, &command->cmdopts, &command->cmdenv);
}
apr_status_t
lcn_term_enum_clone( lcn_term_enum_t *term_enum,
lcn_term_enum_t **clone,
apr_pool_t *pool )
{
apr_status_t s;
do
{
lcn_index_input_t *istream;
LCNCE( lcn_index_input_clone( term_enum->istream, &istream, pool ) );
LCNCE( lcn_segment_term_enum_create( clone, istream, term_enum->field_infos,
term_enum->is_index, pool ) );
LCNCE( lcn_term_enum_grow_buffer( *clone, term_enum->buffer_size) );
apr_cpystrn( (*clone)->term->text, term_enum->term->text, term_enum->buffer_size - 1 );
(*clone)->term->field = term_enum->term->field;
apr_cpystrn( (*clone)->prev->text, term_enum->prev->text, term_enum->buffer_size - 1);
(*clone)->prev->field = term_enum->prev->field;
*((*clone)->term_info) = *(term_enum->term_info);
(*clone)->is_clone = LCN_TRUE;
(*clone)->position = term_enum->position;
LCNCE( lcn_term_enum_seek( *clone, lcn_index_input_file_pointer( term_enum->istream ),
(*clone)->position, term_enum->term, term_enum->term_info ) );
}
while(0);
return s;
}
static int status_handler(request_rec *r)
{
if ( apr_table_get(r->headers_in,"Host"))
{
memset(myVhost, '\0', sizeof(myVhost));
apr_cpystrn(myVhost, apr_table_get(r->headers_in,"Host"), sizeof(myVhost));
r->server->server_hostname = myVhost;
(void)ap_update_child_status(r->connection->sbh, SERVER_BUSY_WRITE, r);
}
return DECLINED;
}
static int pre_connection(conn_rec *c)
{
llzr_config *conf = ap_get_module_config (c->base_server->module_config, &llzr_module);
sb_handle *sbh = c->sbh;
redis = conf->redisconn;
reply = conf->redisreply;
/* loop index variables */
int i;
int j;
/* running count of number of connections from this address */
int ip_count = 0;
/* scoreboard data structure */
worker_score *ws_record;
ws_record = &ap_scoreboard_image->servers[sbh->child_num][sbh->thread_num];
apr_cpystrn(ws_record->client, c->remote_ip, sizeof(ws_record->client));
char *client_ip = ws_record->client;
/* Count up the number of connections we are handling right now from this IP address */
for (i = 0; i < server_limit; ++i) {
for (j = 0; j < thread_limit; ++j) {
ws_record = ap_get_scoreboard_worker(i, j);
switch (ws_record->status) {
case SERVER_BUSY_READ:
if (strcmp(client_ip, ws_record->client) == 0)
ip_count++;
break;
default:
break;
}
}
}
if (ip_count > conf->limit) {
ap_log_error(APLOG_MARK, APLOG_WARNING, 0, NULL, "Rejected, too many connections in READ state from %s", c->remote_ip);
return OK;
} else {
return DECLINED;
}
}
void nx_exception_init(nx_exception_t *e,
const char *caused_by,
const char *file,
int line,
const char *func,
apr_status_t code,
const char *fmt,
...)
{
va_list ap;
int32_t i;
ASSERT(e != NULL);
memset(e, 0, sizeof(nx_exception_t));
for ( i = 0; i < NX_EXCEPTION_THROWLIST_SIZE; i++ )
{
e->throwlist[i].msgoffs = -1;
}
e->code = code;
if ( caused_by == NULL )
{
(e->caused_by)[0] = '\0';
}
else
{
apr_cpystrn(e->caused_by, caused_by, sizeof(e->caused_by));
}
if ( fmt != NULL )
{
va_start(ap, fmt);
nx_exception_add_message(e, file, line, func, fmt, ap);
va_end(ap);
}
else
{
va_start(ap, fmt);
nx_exception_add_message(e, file, line, func, NULL, ap);
va_end(ap);
}
}
/**
* base64 encode the authentication data and build an authentication
* header in this format:
* [SCHEME] [BASE64 of auth DATA]
*/
void serf__encode_auth_header(const char **header,
const char *scheme,
const char *data, apr_size_t data_len,
apr_pool_t *pool)
{
apr_size_t encoded_len, scheme_len;
char *ptr;
encoded_len = apr_base64_encode_len(data_len);
scheme_len = strlen(scheme);
ptr = apr_palloc(pool, encoded_len + scheme_len + 1);
*header = ptr;
apr_cpystrn(ptr, scheme, scheme_len + 1);
ptr += scheme_len;
*ptr++ = ' ';
apr_base64_encode(ptr, data, data_len);
}
void
cleaning_shm_history_from_expired_session(request_rec *r)
{
mod_but_server_t *config = ap_get_module_config(r->server->module_config, &but_module);
apr_time_t curtime = apr_time_now();
apr_time_t tnow = apr_time_sec(curtime);
int y;
for (y = 0; y < MOD_BUT_SESSION_HISTORY_COUNT; y++) {
mod_but_cookie_history *c_history = apr_rmm_addr_get(cs_rmm_history, off_history[y]);
apr_time_t tdelete = c_history->session_delete_time;
if (apr_strnatcmp(c_history->session_value, "empty")) {
if ((tnow - tdelete) > config->session_timeout_history) {
//ERRLOG_INFO("(SHM HISTORY) Cleaning: Delta between tnow and tdelete %d and session value %s", tnow-tdelete, c_history->session_value);
apr_cpystrn(c_history->session_value, "empty", sizeof(c_history->session_value));
c_history->session_delete_time = 0;
}
}
}
}
/**
* base64 encode the authentication data and build an authentication
* header in this format:
* [PROTOCOL] [BASE64 AUTH DATA]
*/
void
svn_ra_serf__encode_auth_header(const char * protocol, char **header,
const char * data, apr_size_t data_len,
apr_pool_t *pool)
{
apr_size_t encoded_len, proto_len;
char * ptr;
encoded_len = apr_base64_encode_len(data_len);
proto_len = strlen(protocol);
*header = apr_palloc(pool, encoded_len + proto_len + 1);
ptr = *header;
apr_cpystrn(ptr, protocol, proto_len + 1);
ptr += proto_len;
*ptr++ = ' ';
apr_base64_encode(ptr, data, data_len);
}
APU_DECLARE(char *) apr_xml_parser_geterror(apr_xml_parser *parser,
char *errbuf,
apr_size_t errbufsize)
{
int error = parser->error;
const char *msg;
/* clear our record of an error */
parser->error = 0;
switch (error) {
case 0:
msg = "No error.";
break;
case APR_XML_NS_ERROR_UNKNOWN_PREFIX:
msg = "An undefined namespace prefix was used.";
break;
case APR_XML_NS_ERROR_INVALID_DECL:
msg = "A namespace prefix was defined with an empty URI.";
break;
case APR_XML_ERROR_EXPAT:
(void) apr_snprintf(errbuf, errbufsize,
"XML parser error code: %s (%d)",
XML_ErrorString(parser->xp_err), parser->xp_err);
return errbuf;
case APR_XML_ERROR_PARSE_DONE:
msg = "The parser is not active.";
break;
default:
msg = "There was an unknown error within the XML body.";
break;
}
(void) apr_cpystrn(errbuf, msg, errbufsize);
return errbuf;
}
int output_dirsync_status(music_query_t* music_query){
int i = 0;
apr_bucket_brigade* output_bb = music_query->output->bucket_brigade;
apr_table_add(music_query->output->headers,"Access-Control-Allow-Origin", "*");
apr_cpystrn((char*)music_query->output->content_type, "application/json", 255);
apr_brigade_puts(music_query->output->bucket_brigade, NULL,NULL, "{\n");
//Print Status
if(music_query->globals->music_dirs != NULL){
apr_brigade_puts(output_bb, NULL,NULL,"\t\"dir_sync_status\" : {\n");
for(i = 0; i < music_query->globals->music_dirs->nelts; i++){
dir_t* dir = &(((dir_t*)music_query->globals->music_dirs->elts)[i]);
apr_brigade_printf(output_bb, NULL, NULL, "\t\t\"%s\" : {\n",dir->path);
apr_brigade_printf(output_bb, NULL,NULL, "\t\t\"Progress\" : \"%.2f\",\n",dir->stats->sync_progress);
apr_brigade_printf(output_bb, NULL,NULL, "\t\t\"Files Scanned\" : \"%d\"\n", dir->stats->files_scanned);
apr_brigade_printf(output_bb, NULL, NULL, "\t\t}");
if(i < (music_query->globals->music_dirs->nelts - 1)){
apr_brigade_printf(output_bb, NULL, NULL, ",");
}
}
apr_brigade_puts(output_bb, NULL,NULL,"\t},\n");
}
apr_brigade_puts(output_bb, NULL,NULL,"\t\"db_status\" : ");
output_db_result_json(music_query->results,music_query->db_query,music_query->output);
apr_brigade_puts(output_bb, NULL,NULL,"\n,");
print_error_messages(music_query->pool,output_bb, music_query->error_messages);
apr_brigade_puts(output_bb, NULL,NULL,"\n}\n");
return 0;
}
// Same as apr_helper_file_gets, but new line is stripped from line end
apr_status_t apr_helper_file_gets(char* str, size_t size, apr_file_t* thefile)
{
apr_status_t rv = APR_INCOMPLETE;
static char buf[1024];
memset(buf, 0, 1024);
try {
rv = apr_file_gets(buf, 1024, thefile);
if (rv == APR_SUCCESS)
{
size_t str_len = strlen(buf);
size_t dst_len = str_len + 1;
if ((strstr(buf, LFCR) != NULL) || (strstr(buf, CRLF) != NULL))
{
dst_len -= 2;
}
else if (strstr(buf, LF) != NULL)
{
dst_len -= 1;
}
if (dst_len > size)
{
dst_len = size;
}
apr_cpystrn(str, buf, dst_len);
rv = APR_SUCCESS;
}
else
{
rv = APR_EGENERAL;
}
}
catch (std::bad_alloc&) {
rv = APR_EGENERAL;
}
return rv;
}
AP_DECLARE(apr_size_t) ap_regerror(int errcode, const ap_regex_t *preg,
char *errbuf, apr_size_t errbuf_size)
{
const char *message, *addmessage;
apr_size_t length, addlength;
message = (errcode >= (int)(sizeof(pstring) / sizeof(char *))) ?
"unknown error code" : pstring[errcode];
length = strlen(message) + 1;
addmessage = " at offset ";
addlength = (preg != NULL && (int)preg->re_erroffset != -1) ?
strlen(addmessage) + 6 : 0;
if (errbuf_size > 0) {
if (addlength > 0 && errbuf_size >= length + addlength)
apr_snprintf(errbuf, errbuf_size, "%s%s%-6d", message, addmessage,
(int)preg->re_erroffset);
else
apr_cpystrn(errbuf, message, errbuf_size);
}
return length + addlength;
}
/** Register/install service in SCM */
static apt_bool_t uni_service_register(const char *root_dir_path, apr_pool_t *pool,
const char *name,
apt_bool_t autostart,
unsigned long recover,
int log_priority,
const char *disp_name,
const char *description)
{
apr_status_t status;
char buf[4096];
static const size_t len = sizeof(buf);
size_t pos = 0;
char *root_dir;
SERVICE_DESCRIPTION desc;
SC_HANDLE sch_service;
SC_HANDLE sch_manager;
/* Normalize root directory path and make it absolute */
status = apr_filepath_merge(&root_dir, NULL, root_dir_path,
APR_FILEPATH_NOTRELATIVE | APR_FILEPATH_NATIVE | APR_FILEPATH_TRUENAME, pool);
if (status != APR_SUCCESS) {
printf("Error making root directory absolute: %d %.512s\n", status,
apr_strerror(status, buf, 512));
return FALSE;
}
buf[pos++] = '"';
pos = apr_cpystrn(buf + pos, root_dir, len - pos) - buf;
if ((buf[pos - 1] != '\\') && (pos < len))
/* Add trailing backslash */
buf[pos++] = '\\';
pos = apr_cpystrn(buf + pos, "bin\\unimrcpserver.exe\" --service -o 2", len - pos) - buf;
if (log_priority >= 0) {
pos = apr_cpystrn(buf + pos, " -l ", len - pos) - buf;
if (pos < len - 34)
pos += strlen(itoa(log_priority, buf + pos, 10));
}
if (name) {
pos = apr_cpystrn(buf + pos, " --name \"", len - pos) - buf;
pos = apr_cpystrn(buf + pos, name, len - pos) - buf;
if ((buf[pos - 1] == '\\') && (pos < len))
/* `\"' might be misinterpreted as escape, so replace `\' with `\\' */
buf[pos++] = '\\';
if (pos < len)
buf[pos++] = '"';
}
pos = apr_cpystrn(buf + pos, " --root-dir \"", len - pos) - buf;
pos = apr_cpystrn(buf + pos, root_dir, len - pos) - buf;
if ((buf[pos - 1] == '\\') && (pos < len))
/* `\"' might be misinterpreted as escape, so replace `\' with `\\' */
buf[pos++] = '\\';
if (pos < len)
buf[pos++] = '"';
if (pos < len)
buf[pos] = 0;
else {
puts("Service Command Too Long");
return FALSE;
}
if (!disp_name || !*disp_name) {
if (name)
disp_name = apr_pstrcat(pool, name, " ", "UniMRCP Server", NULL);
else
disp_name = "UniMRCP Server";
}
if (!description || !*description)
description = "Launches UniMRCP Server";
sch_manager = OpenSCManager(0,0,SC_MANAGER_ALL_ACCESS);
if(!sch_manager) {
winerror("Failed to Open SCManager");
return FALSE;
}
sch_service = CreateService(
sch_manager,
name ? name : WIN_SERVICE_NAME,
disp_name,
GENERIC_EXECUTE | SERVICE_CHANGE_CONFIG,
SERVICE_WIN32_OWN_PROCESS,
autostart ? SERVICE_AUTO_START : SERVICE_DEMAND_START,
SERVICE_ERROR_NORMAL,
buf,0,0,0,0,0);
if(!sch_service) {
winerror("Failed to Create Service");
CloseServiceHandle(sch_manager);
return FALSE;
}
desc.lpDescription = (char *) description;
if(!ChangeServiceConfig2(sch_service,SERVICE_CONFIG_DESCRIPTION,&desc)) {
winerror("Failed to Set Service Description");
}
if (recover) {
SERVICE_FAILURE_ACTIONS sfa;
SC_ACTION action;
sfa.dwResetPeriod = 0;
sfa.lpCommand = "";
sfa.lpRebootMsg = "";
sfa.cActions = 1;
sfa.lpsaActions = &action;
action.Delay = recover * 1000;
action.Type = SC_ACTION_RESTART;
if (!ChangeServiceConfig2(sch_service,SERVICE_CONFIG_FAILURE_ACTIONS,&sfa)) {
winerror("Failed to Set Service Restart on Failure");
}
}
CloseServiceHandle(sch_service);
CloseServiceHandle(sch_manager);
printf("UniMRCP service %s registered\n", name ? name : WIN_SERVICE_NAME);
return TRUE;
}
