void ResetTLDStatistics( void )
{
lnode_t *tn, *tn2;
TLD *t;
tn = list_first( tldstatlist );
while( tn != NULL )
{
t = lnode_get( tn );
ResetStatistic( &t->users );
if( t->users.current == 0 )
{
/* don't delete the tld entry ??? as its our "unknown" entry */
if( ircstrcasecmp( t->tld, UNKNOWN_COUNTRY_CODE ) )
{
tn2 = list_next( tldstatlist, tn );
ns_free( t );
list_delete_destroy_node( tldstatlist, tn );
tn = tn2;
continue;
}
}
tn = list_next( tldstatlist, tn );
}
}
/**
* Export tld struct to xml file
*
* @param file is the name that will be used
* @return void - no returend value
*
*/
void xml_export_tld(char *file)
{
FILE *ptr;
TLD *t;
lnode_t *tn;
ptr = new_xml(file);
SET_SEGV_LOCATION();
if (ptr) {
xml_write_header(ptr);
xml_write_block_top(ptr, "tld");
list_sort(Thead, sortusers);
tn = list_first(Thead);
while (tn) {
t = lnode_get(tn);
denora_cmd_pong(ServerName, ServerName);
xml_write_block_top(ptr, "domain");
xml_write_tag(ptr, "countrycode", t->countrycode);
xml_write_tag(ptr, "country", t->country);
xml_write_tag_int(ptr, "current", t->count);
xml_write_tag_int(ptr, "overall", t->overall);
xml_write_block_bottom(ptr, "domain");
tn = list_next(Thead, tn);
}
xml_write_block_bottom(ptr, "tld");
xml_write_footer(ptr);
}
}
/**
* Export ctcp struct to xml file
*
* @param file is the name that will be used
* @return void - no returend value
*
*/
void xml_export_ctcp(char *file)
{
FILE *ptr;
CTCPVerStats *c;
lnode_t *tn;
ptr = new_xml(file);
SET_SEGV_LOCATION();
if (ptr) {
xml_write_header(ptr);
xml_write_block_top(ptr, "ctcp");
tn = list_first(CTCPhead);
while (tn) {
c = lnode_get(tn);
xml_write_block_top(ptr, "client");
xml_write_tag(ptr, "version", c->version);
xml_write_tag_int(ptr, "current", c->count);
xml_write_tag_int(ptr, "overall", c->overall);
xml_write_block_bottom(ptr, "client");
tn = list_next(CTCPhead, tn);
}
xml_write_block_bottom(ptr, "ctcp");
xml_write_footer(ptr);
}
}
void html_ctcp_table(FILE * ptr)
{
CTCPVerStats *c;
lnode_t *tn;
char *tempc;
int x = 0;
if (ptr) {
fprintf(ptr, "%s", getstring(NULL, HTML_CTCP_HEADER));
list_sort(CTCPhead, sortctcp);
tn = list_first(CTCPhead);
while (tn) {
c = lnode_get(tn);
if (c->overall) {
tempc = char_encode(c->version);
dfprintf(ptr, getstring(NULL, HTML_CTCP_CONTENT),
tempc, c->overall);
free(tempc);
x++;
if (x > 10) {
break;
}
}
tn = list_next(CTCPhead, tn);
}
fprintf(ptr, "%s", getstring(NULL, HTML_CTCP_FOOTER));
}
}
CP_C_API cp_status_t cp_register_logger(cp_context_t *context, cp_logger_func_t logger, void *user_data, cp_log_severity_t min_severity) {
logger_t l;
logger_t *lh = NULL;
lnode_t *node = NULL;
cp_status_t status = CP_OK;
CHECK_NOT_NULL(context);
CHECK_NOT_NULL(logger);
cpi_lock_context(context);
cpi_check_invocation(context, CPI_CF_LOGGER, __func__);
do {
// Check if logger already exists and allocate new holder if necessary
l.logger = logger;
if ((node = list_find(context->env->loggers, &l, comp_logger)) == NULL) {
lh = malloc(sizeof(logger_t));
node = lnode_create(lh);
if (lh == NULL || node == NULL) {
status = CP_ERR_RESOURCE;
break;
}
lh->logger = logger;
lh->plugin = context->plugin;
list_append(context->env->loggers, node);
} else {
lh = lnode_get(node);
}
// Initialize or update the logger holder
lh->user_data = user_data;
lh->min_severity = min_severity;
// Update global limits
update_logging_limits(context);
} while (0);
// Report error
if (status == CP_ERR_RESOURCE) {
cpi_error(context, N_("Logger could not be registered due to insufficient memory."));
} else if (cpi_is_logged(context, CP_LOG_DEBUG)) {
char owner[64];
/* TRANSLATORS: %s is the context owner */
cpi_debugf(context, N_("%s registered a logger."), cpi_context_owner(context, owner, sizeof(owner)));
}
cpi_unlock_context(context);
// Release resources on error
if (status != CP_OK) {
if (node != NULL) {
lnode_destroy(node);
}
if (lh != NULL) {
free(lh);
}
}
return status;
}
int list_is_sorted(list_t *list, int compare(const void *, const void *))
{
lnode_t *node, *next, *nil;
next = nil = list_nil(list);
node = list_first_priv(list);
if (node != nil)
next = lnode_next(node);
for (; next != nil; node = next, next = lnode_next(next)) {
if (compare(lnode_get(node), lnode_get(next)) > 0)
return 0;
}
return 1;
}
static void process_unregister_logger(list_t *list, lnode_t *node, void *plugin) {
logger_t *lh = lnode_get(node);
if (plugin == NULL || lh->plugin == plugin) {
list_delete(list, node);
lnode_destroy(node);
free(lh);
}
}
lnode_t *list_find(list_t *list, const void *key, int compare(const void *, const void *))
{
lnode_t *node;
for (node = list_first_priv(list); node != list_nil(list); node = node->next) {
if (compare(lnode_get(node), key) == 0)
return node;
}
return 0;
}
/*
* Find list entry and return data pointer
*/
void *
lnode_find (const list_t * list, const void *key, int compare (const void *, const void *))
{
lnode_t * ln;
ln = list_find (list, key, compare);
if (ln) {
return lnode_get (ln);
}
return NULL;
}
int check_routing(list_t *found, Route *route, int expected_count, const char *route_data)
{
check(list_count(found) == expected_count, "Didn't find right number of routes: got %d, expected %d.",
(int)list_count(found), expected_count);
route = lnode_get(list_first(found));
debug("Route returned: %s", (const char *)route->data);
check(route->data == route_data, "Wrong data returned.");
return 1;
error:
return 0;
}
static int AST_destroy_list(list_t *data)
{
lnode_t *n = NULL;
for(n = list_first(data); n != NULL; n = list_next(data, n)) {
AST_destroy_value((Value *)lnode_get(n));
}
list_destroy_nodes(data);
list_destroy(data);
return 0;
}
/**
* Updates the context logging limits. The caller must have locked the
* context.
*/
static void update_logging_limits(cp_context_t *context) {
lnode_t *node;
int nms = CP_LOG_NONE;
node = list_first(context->env->loggers);
while (node != NULL) {
logger_t *lh = lnode_get(node);
if (lh->min_severity < nms) {
nms = lh->min_severity;
}
node = list_next(context->env->loggers, node);
}
context->env->log_min_severity = nms;
}
/*
* Destroy all nodes in list and free associated data pointer.
*/
void
list_destroy_auto (list_t * list)
{
lnode_t *ln;
ln = list_first (list);
while (ln) {
void *ptr = ( void * )lnode_get (ln);
ns_free (ptr);
ln = list_next (list, ln);
}
list_destroy_nodes (list);
list_destroy (list);
}
void GetTLDStats( const TLDStatHandler handler, const void *v )
{
const TLD *t;
lnode_t *tn;
list_sort( tldstatlist, sortusers );
tn = list_first( tldstatlist );
while( tn != NULL )
{
t = lnode_get( tn );
handler( t, v );
tn = list_next( tldstatlist, tn );
}
}
void
list_merge (list_t * dest, list_t * sour, int compare (const void *, const void *))
{
lnode_t *dn, *sn, *tn;
lnode_t *d_nil = list_nil (dest), *s_nil = list_nil (sour);
/* Nothing to do if source and destination list are the same. */
if (dest == sour)
return;
/* overflow check */
nassert (list_count (sour) + list_count (dest) >= list_count (sour));
/* lists must be sorted */
nassert (list_is_sorted (sour, compare));
nassert (list_is_sorted (dest, compare));
dn = list_first_priv (dest);
sn = list_first_priv (sour);
while (dn != d_nil && sn != s_nil) {
if (compare (lnode_get (dn), lnode_get (sn)) >= 0) {
tn = lnode_next (sn);
list_delete (sour, sn);
list_ins_before (dest, sn, dn);
sn = tn;
} else {
dn = lnode_next (dn);
}
}
if (dn != d_nil)
return;
if (sn != s_nil)
list_transfer (dest, sour, sn);
}
Timer *FindTimer( const char *name )
{
lnode_t *tn;
Timer *t;
tn = list_first(timerlist);
while (tn != NULL) {
t = lnode_get(tn);
if (!ircstrcasecmp(t->name, name))
return t;
tn = list_next(timerlist, tn);
}
dlog( DEBUG3, "FindTimer: %s not found", name );
return NULL;
}
CP_HIDDEN void cpi_destroy_all_contexts(void) {
cpi_lock_framework();
if (contexts != NULL) {
lnode_t *node;
while ((node = list_last(contexts)) != NULL) {
cpi_unlock_framework();
cp_destroy_context(lnode_get(node));
cpi_lock_framework();
}
list_destroy(contexts);
contexts = NULL;
}
cpi_unlock_framework();
}
static void NextSchedule() {
lnode_t *CurNode;
Timer *CurTimer;
struct timeval tv;
/* finally, update the Event Based Timers */
update_time_now();
CurNode = list_first(timerlist);
if (CurNode) {
CurTimer = lnode_get(CurNode);
timerclear( &tv );
tv.tv_sec = CurTimer->nextrun - me.now;;
if (tv.tv_sec <= 0) {
/* only run one timer at a time, so wake up in 10 seconds */
tv.tv_sec = 10;
}
evtimer_add( evtimers, &tv );
dlog(DEBUG3, "Timers will next run in %d Seconds (or around %s)", (int)tv.tv_sec, sftime(CurTimer->nextrun));
}
}
int check_routing(list_t *found, Route *route, int expected_count, const char *route_data)
{
if(list_first(found)) {
route = lnode_get(list_first(found));
}
check(list_count(found) == expected_count, "Didn't find right number of routes: got %d, expected %d.",
(int)list_count(found), expected_count);
if(route_data == NULL) {
check(route == NULL, "Should have no routes found.");
} else {
check(route->data == route_data, "Wrong data returned.");
}
return 1;
error:
if(route) debug("Route returned: %s", (const char *)route->data);
return 0;
}
INT16 CDlpFile_List(CDlpFile* _this)
{
CFILE_FTYPE* lpType = NULL;
lnode_t* lpNode = NULL;
printf("\n"); dlp_fprint_x_line(stdout,'-',80);
printf( "\n Name \tClass \tMode \tDescription\n");
dlp_fprint_x_line(stdout,'-',80); printf("\n");
for(lpNode=list_first(_this->m_lpFtypes); lpNode; lpNode=list_next(_this->m_lpFtypes,lpNode))
{
lpType = (CFILE_FTYPE*)lnode_get(lpNode);
DLPASSERT(lpType);
printf( " %-10s\t%-10s\t%s\t%s\n",lpType->lpName,lpType->lpClassName,
lpType->nMode==IMPORT_FILE?"Import":"Export",lpType->lpDescr);
}
dlp_fprint_x_line(stdout,'-',80); printf("\n");
return O_K;
}
int SetTimerInterval( const char *name, int interval )
{
Timer *timer;
lnode_t *tn;
SET_SEGV_LOCATION();
tn = list_first(timerlist);
while (tn != NULL) {
timer = lnode_get(tn);
if (!ircstrcasecmp(timer->name, name)) {
timer->interval = interval;
dlog( DEBUG2, "SetTimerInterval: timer interval for %s (%s) set to %d", name, timer->moduleptr->info->name, interval );
TimerCalcNextRun(timer, tn);
return NS_SUCCESS;
}
tn = list_next(timerlist, tn);
}
dlog(DEBUG2, "SetTimerInterval: timer %s not found", name);
return NS_FAILURE;
}
void* dequeue(queue_t *q)
{
lnode_t *n;
pthread_mutex_lock(&q->lock);
if (list_isempty(q->list)) {
pthread_cond_wait(&q->notempty, &q->lock);
}
if (list_isfull(q->list)) {
n = list_del_first(q->list);
pthread_cond_broadcast(&q->notfull);
}
else {
n = list_del_first(q->list);
}
pthread_mutex_unlock(&q->lock);
return lnode_get(n);
}
int AST_walk_list(tst_t *settings, list_t *data, ast_walk_cb cb)
{
lnode_t *n = NULL;
int rc = 0;
for(n = list_first(data); n != NULL; n = list_next(data, n)) {
Value *ref = lnode_get(n);
check(ref, "List got a NULL value in it. Huh?");
Value *found = Value_resolve(settings, ref);
check(found, "Invalid reference: %s", bdata(ref->as.ref->data));
rc = cb(settings, found);
check_debug(rc == 0, "Failure processing config file. Aborting.");
}
return 0;
error:
return -1;
}
int ns_cmd_timerlist( const CmdParams *cmdparams )
{
Timer *timer = NULL;
lnode_t *tn;
SET_SEGV_LOCATION();
irc_prefmsg( ns_botptr, cmdparams->source, __( "Timer List:", cmdparams->source ) );
tn = list_first(timerlist);
while( tn != NULL )
{
timer = lnode_get( tn );
irc_prefmsg( ns_botptr, cmdparams->source, "%s:", timer->moduleptr->info->name );
irc_prefmsg( ns_botptr, cmdparams->source, __( "Timer: %s", cmdparams->source ), timer->name );
switch( timer->type )
{
case TIMER_TYPE_DAILY:
irc_prefmsg( ns_botptr, cmdparams->source, "Timer Type: Daily");
break;
case TIMER_TYPE_WEEKLY:
irc_prefmsg( ns_botptr, cmdparams->source, "Timer Type: Weekly");
break;
case TIMER_TYPE_MONTHLY:
irc_prefmsg( ns_botptr, cmdparams->source, "Timer Type: Monthly");
break;
case TIMER_TYPE_INTERVAL:
irc_prefmsg( ns_botptr, cmdparams->source, "Timer Type: Interval");
irc_prefmsg( ns_botptr, cmdparams->source, __( "Interval: %ld", cmdparams->source ), ( long )timer->interval );
break;
case TIMER_TYPE_COUNTDOWN:
irc_prefmsg( ns_botptr, cmdparams->source, "Timer Type: Countdown");
irc_prefmsg( ns_botptr, cmdparams->source, __( "Interval: %ld", cmdparams->source ), ( long )timer->interval );
break;
}
irc_prefmsg( ns_botptr, cmdparams->source, __( "Next run at: %s", cmdparams->source ), sftime(timer->nextrun));
irc_prefmsg( ns_botptr, cmdparams->source, __( "Last run at: %s", cmdparams->source ), sftime(timer->lastrun));
tn = list_next(timerlist, tn);
}
irc_prefmsg( ns_botptr, cmdparams->source, __( "End of list.", cmdparams->source ) );
return 0;
}
void CheckTimers_cb( int notused, short event, void *arg )
{
Timer *timer = NULL;
lnode_t *tn;
SET_SEGV_LOCATION();
update_time_now();
/* We only run Timers one at a time */
tn = list_first(timerlist);
timer = lnode_get( tn );
/* If a module is not yet synched, reset it's lastrun */
if( !IsModuleSynched( timer->moduleptr ) ) {
timer->lastrun = ( int ) me.now;
} else if (timer->nextrun <= me.now) {
if( setjmp( sigvbuf ) == 0 ) {
dlog( DEBUG10, "run_mod_timers: Running timer %s for module %s", timer->name, timer->moduleptr->info->name );
SET_RUN_LEVEL( timer->moduleptr );
if( timer->handler( timer->userptr ) < 0 ) {
dlog( DEBUG2, "run_mod_timers: Deleting Timer %s for Module %s as requested", timer->name, timer->moduleptr->info->name );
list_delete_destroy_node(timerlist, tn);
ns_free( timer );
NextSchedule();
} else {
timer->lastrun = ( int ) me.now;
TimerCalcNextRun(timer, tn);
}
RESET_RUN_LEVEL();
#if 0
if( timer->type == TIMER_TYPE_COUNTDOWN ) {
hash_scan_delete_destroy_node( timerlist, tn );
ns_free( timer );
}
#endif
} else {
nlog( LOG_CRITICAL, "run_mod_timers: setjmp() failed, can't call module %s", timer->moduleptr->info->name );
NextSchedule();
}
}
}
static void do_log(cp_context_t *context, cp_log_severity_t severity, const char *msg) {
lnode_t *node;
const char *apid = NULL;
assert(cpi_is_context_locked(context));
if (context->env->in_logger_invocation) {
cpi_fatalf(_("Encountered a recursive logging request within a logger invocation."));
}
if (context->plugin != NULL) {
apid = context->plugin->plugin->identifier;
}
context->env->in_logger_invocation++;
node = list_first(context->env->loggers);
while (node != NULL) {
logger_t *lh = lnode_get(node);
if (severity >= lh->min_severity) {
lh->logger(severity, msg, apid, lh->user_data);
}
node = list_next(context->env->loggers, node);
}
context->env->in_logger_invocation--;
}
CP_C_API void cp_unregister_logger(cp_context_t *context, cp_logger_func_t logger) {
logger_t l;
lnode_t *node;
CHECK_NOT_NULL(context);
CHECK_NOT_NULL(logger);
cpi_lock_context(context);
cpi_check_invocation(context, CPI_CF_LOGGER, __func__);
l.logger = logger;
if ((node = list_find(context->env->loggers, &l, comp_logger)) != NULL) {
logger_t *lh = lnode_get(node);
list_delete(context->env->loggers, node);
lnode_destroy(node);
free(lh);
update_logging_limits(context);
}
if (cpi_is_logged(context, CP_LOG_DEBUG)) {
char owner[64];
/* TRANSLATORS: %s is the context owner */
cpi_debugf(context, N_("%s unregistered a logger."), cpi_context_owner(context, owner, sizeof(owner)));
}
cpi_unlock_context(context);
}
void FiniTimers( void )
{
lnode_t *tn;
Timer *timer;
evtimer_del( evtimers );
os_free( evtimers );
DelTimer("PingServers");
DelTimer("FlushLogs");
if (nsconfig.setservertimes > 0)
DelTimer("SetServersTime");
DelTimer("ResetLogs");
if (list_count(timerlist) > 0) {
tn = list_first(timerlist);
while( tn != NULL )
{
timer = lnode_get( tn );
dlog( DEBUG3, "FiniTimers() BUG: Timer %s not deleted for module %s", timer->name, timer->moduleptr->info->name );
tn = list_next(timerlist, tn);
}
}
list_destroy( timerlist );
}
int del_timers( const Module *mod_ptr )
{
Timer *timer;
lnode_t *tn, *tn2;
tn = list_first(timerlist);
while( tn != NULL )
{
tn2 = list_next(timerlist, tn);
timer = lnode_get( tn );
if( timer->moduleptr == mod_ptr )
{
dlog( DEBUG1, "del_timers: deleting timer %s from module %s.", timer->name, mod_ptr->info->name );
list_delete_destroy_node(timerlist, tn);
#ifdef USE_PERL
if( IS_PERL_MOD( timer->moduleptr ) )
ns_free( timer->userptr );
#endif /* USE_PERL */
ns_free( timer );
}
tn = tn2;
}
return NS_SUCCESS;
}
int DelTimer( const char *name )
{
Timer *timer;
lnode_t *tn;
SET_SEGV_LOCATION();
tn = list_first(timerlist);
while (tn != NULL) {
timer = lnode_get(tn);
if (!ircstrcasecmp(timer->name, name)) {
dlog( DEBUG2, "DelTimer: removed timer %s for module %s", name, timer->moduleptr->info->name );
list_delete_destroy_node(timerlist, tn);
#ifdef USE_PERL
if( IS_PERL_MOD( timer->moduleptr ) )
ns_free( timer->userptr );
#endif /* USE_PERL */
ns_free( timer );
return NS_SUCCESS;
}
tn = list_next(timerlist, tn);
}
dlog(DEBUG2, "DelTimer: Timer %s not found", name);
return NS_FAILURE;
}
