void thread_deregister( pthread_t pthreadId )
{
BalancedBTreeItem_t *item;
Thread_t *thread;
item = BalancedBTreeFind( ThreadTree, (void *)&pthreadId, UNLOCKED, FALSE );
if( !item ) {
return;
}
BalancedBTreeRemove( ThreadTree, item, UNLOCKED, TRUE );
thread = (Thread_t *)item->item;
LogPrint( LOG_INFO, "Removed Thread %ld as \"%s\"", pthreadId,
(char *)thread->name );
if( thread->callbacks ) {
memfree( thread->callbacks );
}
memfree( thread );
memfree( item );
if( !pthread_equal( pthread_self(), pthreadId ) ) {
pthread_join( pthreadId, NULL );
}
}
SigFunc_t ThreadGetHandler( pthread_t threadId, int signum, void **parg )
{
BalancedBTreeItem_t *item;
Thread_t *thread;
item = BalancedBTreeFind( ThreadTree, (void *)&threadId, UNLOCKED, FALSE );
if( !item ) {
return( NULL );
}
thread = (Thread_t *)item->item;
if( parg ) {
*parg = NULL;
}
switch( signum ) {
case SIGUSR2:
if( parg ) {
if( thread->callbacks ) {
*parg = thread->callbacks->sigusr2Arg;
} else {
*parg = NULL;
}
}
if( !thread->callbacks || !thread->callbacks->sigusr2Func ) {
return( do_backtrace );
}
return( thread->callbacks->sigusr2Func );
break;
case SIGHUP:
if( parg ) {
if( thread->callbacks ) {
*parg = thread->callbacks->sighupArg;
} else {
*parg = NULL;
}
}
if( !thread->callbacks || !thread->callbacks->sighupFunc ) {
return( NULL );
}
return( thread->callbacks->sighupFunc );
break;
case SIGWINCH:
#if 0
if( !Daemon && pthread_equal( threadId, cursesOutThreadId ) ) {
return( cursesSigwinch );
}
#endif
break;
default:
break;
}
return( NULL );
}
void cursesServerCleanup( void *arg )
{
IRCServer_t *server;
BalancedBTreeItem_t *item;
int num;
num = -1;
item = BalancedBTreeFind( ServerTree, &num, UNLOCKED );
if( !item ) {
return;
}
BalancedBTreeRemove( ServerTree, item, UNLOCKED, TRUE );
server = (IRCServer_t *)item->item;
free( server->server );
free( server->password );
free( server->nick );
free( server->username );
free( server->realname );
free( server->nickserv );
free( server->nickservmsg );
if( server->menuText ) {
free( server->menuText );
}
free( server );
free( item );
}
char *thread_name( pthread_t pthreadId )
{
BalancedBTreeItem_t *item;
Thread_t *thread;
item = BalancedBTreeFind( ThreadTree, (void *)&pthreadId, UNLOCKED, FALSE );
if( !item ) {
return( NULL );
}
thread = (Thread_t *)item->item;
return( thread->name );
}
IRCChannel_t *FindChannelNum( IRCServer_t *server, int channum )
{
BalancedBTreeItem_t *item;
IRCChannel_t *channel;
if( !server || !ChannelsLoaded ) {
return( NULL );
}
item = BalancedBTreeFind( server->channelNum, (int *)&channum, UNLOCKED );
if( !item ) {
return( NULL );
}
channel = (IRCChannel_t *)item->item;
return( channel );
}
void thread_colors( pthread_t pthreadId, char **bg, char **fg )
{
BalancedBTreeItem_t *item;
Thread_t *thread;
static char *empty = "";
item = BalancedBTreeFind( ThreadTree, (void *)&pthreadId, UNLOCKED, FALSE );
if( !item ) {
*bg = empty;
*fg = empty;
return;
}
thread = (Thread_t *)item->item;
*bg = backgroundColors[thread->background];
*fg = foregroundColors[thread->foreground];
}
IRCServer_t *FindServerNum( int serverId )
{
IRCServer_t *server;
BalancedBTreeItem_t *item;
if( !ChannelsLoaded ) {
return( NULL );
}
item = BalancedBTreeFind( ServerTree, &serverId, UNLOCKED );
if( !item ) {
return( NULL );
}
server = (IRCServer_t *)item->item;
return( server );
}
IRCChannel_t *FindChannel(IRCServer_t *server, const char *channame)
{
BalancedBTreeItem_t *item;
IRCChannel_t *channel;
if( !server || !ChannelsLoaded ) {
return( NULL );
}
item = BalancedBTreeFind( server->channelName, (char **)&channame,
UNLOCKED );
if( !item ) {
return( NULL );
}
channel = (IRCChannel_t *)item->item;
return( channel );
}
void versionRemove( char *what )
{
BalancedBTreeItem_t *item;
Version_t *vItem;
item = BalancedBTreeFind( versionTree, &what, UNLOCKED );
if( !item ) {
return;
}
vItem = (Version_t *)item->item;
vItem->count--;
if( !vItem->count ) {
BalancedBTreeRemove( versionTree, item, UNLOCKED, TRUE );
free( vItem->what );
free( vItem->version );
free( vItem );
free( item );
}
}
bool pluginUnload( char *name )
{
BalancedBTreeItem_t *item;
Plugin_t *plugin;
if( !name ) {
return( false );
}
item = BalancedBTreeFind( pluginTree, (void *)&name, UNLOCKED );
if( !item ) {
return( false );
}
plugin = (Plugin_t *)item->item;
if( !plugin->loaded ) {
return( false );
}
pluginUnloadItem( plugin );
return( true );
}
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 );
}
void serverKill( BalancedBTreeItem_t *node, IRCServer_t *server, bool unalloc )
{
LinkedListItem_t *listItem, *next;
IRCChannel_t *channel;
BalancedBTreeItem_t *item;
if( server->enabled || server->enabledChanged ) {
server->threadAbort = TRUE;
thread_deregister( server->txThreadId );
thread_deregister( server->threadId );
server->threadAbort = FALSE;
}
if( unalloc ) {
BalancedBTreeRemove( node->btree, node, LOCKED, FALSE );
} else {
server->enabled = FALSE;
}
if( server->txQueue ) {
/* This *might* leak the contents of any queue entries? */
QueueClear( server->txQueue, TRUE );
QueueLock( server->txQueue );
QueueDestroy( server->txQueue );
server->txQueue = NULL;
}
if( server->channels ) {
LinkedListLock( server->channels );
BalancedBTreeLock( server->channelName );
BalancedBTreeLock( server->channelNum );
for( listItem = server->channels->head; listItem; listItem = next ) {
next = listItem->next;
channel = (IRCChannel_t *)listItem;
regexpBotCmdRemove( server, channel );
LinkedListRemove( server->channels, listItem, LOCKED );
item = BalancedBTreeFind( server->channelName,
&channel->channel, LOCKED );
if( item ) {
BalancedBTreeRemove( server->channelName, item, LOCKED,
FALSE );
}
item = BalancedBTreeFind( server->channelNum,
&channel->channelId, LOCKED );
if( item ) {
BalancedBTreeRemove( server->channelNum, item, LOCKED,
FALSE );
}
ThreadAllNotifyChannel( channel );
cursesMenuItemRemove( 2, MENU_CHANNELS, channel->menuText );
free( channel->menuText );
free( channel->channel );
free( channel->fullspec );
free( channel->url );
free( channel );
}
LinkedListDestroy( server->channels );
BalancedBTreeDestroy( server->channelName );
BalancedBTreeDestroy( server->channelNum );
server->channels = NULL;
server->channelName = NULL;
server->channelNum = NULL;
}
if( unalloc ) {
free( server->server );
free( server->password );
free( server->nick );
free( server->username );
free( server->realname );
free( server->nickserv );
free( server->nickservmsg );
free( server->ircInfo.Server );
}
LinkedListLock( server->floodList );
for( listItem = server->floodList->head; listItem; listItem = next ) {
next = listItem->next;
LinkedListRemove( server->floodList, listItem, LOCKED );
free( listItem );
}
LinkedListDestroy( server->floodList );
server->floodList = NULL;
ThreadAllNotifyServer( server );
if( unalloc ) {
cursesMenuItemRemove( 2, MENU_SERVERS, server->menuText );
free( server->menuText );
free( server->threadName );
free( server->txThreadName );
free( server );
free( node );
}
}
void botSighup( int signum, void *arg )
{
IRCServer_t *server;
LinkedListItem_t *listItem, *next;
BalancedBTreeItem_t *item;
IRCChannel_t *channel;
bool newChannel = FALSE;
server = (IRCServer_t *)arg;
if( !server ) {
return;
}
/*
* Check each channel on the server, leave those no longer needed
*/
if( server->channels ) {
LinkedListLock( server->channels );
BalancedBTreeLock( server->channelName );
BalancedBTreeLock( server->channelNum );
for( listItem = server->channels->head; listItem; listItem = next ) {
next = listItem->next;
channel = (IRCChannel_t *)listItem;
if( !channel->visited ) {
channelLeave( server, channel, channel->channel );
regexpBotCmdRemove( server, channel );
LinkedListRemove( server->channels, listItem, LOCKED );
item = BalancedBTreeFind( server->channelName,
&channel->channel, LOCKED );
if( item ) {
BalancedBTreeRemove( server->channelName, item, LOCKED,
FALSE );
}
item = BalancedBTreeFind( server->channelNum,
&channel->channelId, LOCKED );
if( item ) {
BalancedBTreeRemove( server->channelNum, item, LOCKED,
FALSE );
}
ThreadAllNotifyChannel( channel );
cursesMenuItemRemove( 2, MENU_CHANNELS, channel->menuText );
free( channel->menuText );
free( channel->channel );
free( channel->fullspec );
free( channel->url );
free( channel );
} else if( channel->newChannel && channel->enabled &&
!channel->joined && !newChannel ) {
newChannel = TRUE;
transmitMsg( server, TX_JOIN, channel->channel, NULL );
} else if( channel->newChannel && !channel->enabled ) {
channel->newChannel = FALSE;
}
}
BalancedBTreeUnlock( server->channelNum );
BalancedBTreeUnlock( server->channelName );
LinkedListUnlock( server->channels );
}
}
