void mainSighup( int signum, void *arg )
{
/*
* Need to rescan the plugins
*/
LogPrintNoArg( LOG_INFO, "Reloading plugins..." );
plugins_sighup();
/*
* Reload server & channel info -- NOTE: this happens before the bot
* threads get signalled
*/
LogPrintNoArg( LOG_INFO, "Reloading servers & channels..." );
BalancedBTreeLock( ServerTree );
serverUnvisit( ServerTree->root );
db_load_servers();
db_load_channels();
while( serverFlushUnvisited( ServerTree->root ) ) {
/*
* If an unvisited entry is found, we need to loop as removing it can
* mess up the recursion
*/
}
BalancedBTreeAdd( ServerTree, NULL, LOCKED, TRUE );
BalancedBTreeUnlock( ServerTree );
}
void cursesServerNew( void *arg )
{
IRCServer_t *server;
BalancedBTreeItem_t *item;
server = (IRCServer_t *)malloc(sizeof(IRCServer_t));
memset( server, 0, sizeof(IRCServer_t) );
server->serverId = -1;
item = (BalancedBTreeItem_t *)malloc(sizeof(BalancedBTreeItem_t));
item->item = (void *)server;
item->key = (void *)&server->serverId;
BalancedBTreeAdd( ServerTree, item, UNLOCKED, TRUE );
server->server = strdup("");
server->password = strdup("");
server->nick = strdup("");
server->username = strdup("");
server->realname = strdup("");
server->nickserv = strdup("");
server->nickservmsg = strdup("");
cursesRegisterCleanupFunc( cursesServerCleanup );
cursesServerDisplay( server );
}
void plugins_sighup( void )
{
BalancedBTreeLock( pluginTree );
pluginUnvisitTree( pluginTree->root );
db_get_plugins( pluginTree );
pluginInitializeTree( pluginTree->root );
while( pluginFlushUnvisited( pluginTree->root ) ) {
/*
* Keep calling until nothing's been flushed. This allows for the
* fact that the tree will shift around as we delete things, and the
* recursion will be messed up by this.
*/
}
/* Rebalance the tree */
BalancedBTreeAdd( pluginTree, NULL, LOCKED, TRUE );
BalancedBTreeUnlock( pluginTree );
}
void thread_register( pthread_t *pthreadId, char *name,
ThreadCallback_t *callbacks )
{
BalancedBTreeItem_t *item;
Thread_t *thread;
if( !ThreadTree ) {
ThreadTree = BalancedBTreeCreate( NULL, BTREE_KEY_PTHREAD );
if( !ThreadTree ) {
fprintf( stderr, "Couldn't create thread tree!\n" );
_exit( 1 );
}
}
thread = CREATE(Thread_t);
thread->threadId = pthreadId;
thread->name = name;
if( callbacks ) {
thread->callbacks = CREATE(ThreadCallback_t);
memcpy(thread->callbacks, callbacks, sizeof(ThreadCallback_t));
}
threadCount++;
thread->background = (threadCount - 1) / 15;
thread->foreground = (threadCount - 1) % 15;
if( thread->foreground >= thread->background) {
thread->foreground++;
}
item = CREATE(BalancedBTreeItem_t);
item->item = (void *)thread;
item->key = (void *)thread->threadId;
BalancedBTreeAdd( ThreadTree, item, UNLOCKED, TRUE );
LogPrint( LOG_INFO, "Added thread as \"%s%s%s%s%s\" (%d/%d)",
backgroundColors[thread->background],
foregroundColors[thread->foreground], name,
backgroundColors[0], foregroundColors[1],
thread->background, thread->foreground );
}
void versionAdd( char *what, char *version )
{
BalancedBTreeItem_t *item;
Version_t *vItem;
item = BalancedBTreeFind( versionTree, &what, UNLOCKED );
if( item ) {
vItem = (Version_t *)item->item;
vItem->count++;
return;
}
vItem = (Version_t *)malloc(sizeof(Version_t));
item = (BalancedBTreeItem_t *)malloc(sizeof(BalancedBTreeItem_t));
vItem->what = strdup( what );
vItem->version = strdup( version );
vItem->count = 1;
item->item = (void *)vItem;
item->key = (void *)&vItem->what;
BalancedBTreeAdd( versionTree, item, UNLOCKED, TRUE );
}
